1/*
2 * Copyright (C) 2013 Google Inc. All rights reserved.
3 * Copyright (C) 2013-2016 Apple Inc. All rights reserved.
4 * Copyright (C) 2014 University of Washington. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
19 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
25 * THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28// DO NOT EDIT THIS FILE. It is automatically generated from CombinedDomains.json by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
29
30#pragma once
31
32#include "InspectorProtocolTypes.h"
33#include <wtf/JSONValues.h>
34#include <wtf/text/WTFString.h>
35
36namespace Inspector {
37
38
39
40namespace Protocol {
41
42// Versions.
43namespace Audit {
44static constexpr unsigned VERSION = 3;
45} // Audit
46
47namespace Recording {
48static constexpr unsigned VERSION = 1;
49} // Recording
50// End of versions.
51
52
53// Forward declarations.
54namespace Animation {
55class Animation;
56class Effect;
57class Keyframe;
58class TrackingUpdate;
59enum class AnimationState;
60enum class PlaybackDirection;
61enum class FillMode;
62} // Animation
63
64namespace ApplicationCache {
65class ApplicationCacheResource;
66class ApplicationCache;
67class FrameWithManifest;
68} // ApplicationCache
69
70namespace Browser {
71class Extension;
72} // Browser
73
74#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
75namespace CPUProfiler {
76class ThreadInfo;
77class Event;
78} // CPUProfiler
79#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
80
81namespace CSS {
82class CSSStyleId;
83class CSSRuleId;
84class PseudoIdMatches;
85class InheritedStyleEntry;
86class RuleMatch;
87class CSSSelector;
88class SelectorList;
89class CSSStyleAttribute;
90class CSSStyleSheetHeader;
91class CSSStyleSheetBody;
92class CSSRule;
93class SourceRange;
94class ShorthandEntry;
95class CSSPropertyInfo;
96class CSSComputedStyleProperty;
97class CSSStyle;
98class CSSProperty;
99class Grouping;
100class Font;
101class FontVariationAxis;
102enum class StyleSheetOrigin;
103enum class PseudoId;
104enum class CSSPropertyStatus;
105enum class LayoutContextType;
106enum class LayoutContextTypeChangedMode;
107} // CSS
108
109namespace Canvas {
110class ContextAttributes;
111class Canvas;
112#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
113class ShaderProgram;
114#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
115enum class ContextType;
116#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
117enum class ProgramType;
118#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
119#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
120enum class ShaderType;
121#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
122} // Canvas
123
124namespace Console {
125class Channel;
126class ConsoleMessage;
127class CallFrame;
128class StackTrace;
129enum class ChannelSource;
130enum class ChannelLevel;
131} // Console
132
133namespace DOM {
134class Node;
135class DataBinding;
136class EventListener;
137class AccessibilityProperties;
138class RGBAColor;
139class HighlightConfig;
140enum class PseudoType;
141enum class ShadowRootType;
142enum class CustomElementState;
143enum class LiveRegionRelevant;
144} // DOM
145
146namespace DOMDebugger {
147enum class DOMBreakpointType;
148enum class EventBreakpointType;
149} // DOMDebugger
150
151namespace DOMStorage {
152class StorageId;
153} // DOMStorage
154
155namespace Database {
156class Database;
157class Error;
158} // Database
159
160namespace Debugger {
161class Location;
162class BreakpointAction;
163class BreakpointOptions;
164class FunctionDetails;
165class CallFrame;
166class Scope;
167class ProbeSample;
168class AssertPauseReason;
169class BreakpointPauseReason;
170class CSPViolationPauseReason;
171} // Debugger
172
173namespace GenericTypes {
174class SearchMatch;
175} // GenericTypes
176
177namespace Heap {
178class GarbageCollection;
179} // Heap
180
181namespace IndexedDB {
182class DatabaseWithObjectStores;
183class ObjectStore;
184class ObjectStoreIndex;
185class Key;
186class KeyRange;
187class DataEntry;
188class KeyPath;
189} // IndexedDB
190
191namespace LayerTree {
192class IntRect;
193class Layer;
194class CompositingReasons;
195} // LayerTree
196
197#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
198namespace Memory {
199class Event;
200class CategoryData;
201} // Memory
202#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
203
204namespace Network {
205class Headers;
206class ResourceTiming;
207class Request;
208class Response;
209class Metrics;
210class WebSocketRequest;
211class WebSocketResponse;
212class WebSocketFrame;
213class CachedResource;
214class Initiator;
215enum class NetworkStage;
216enum class ResourceErrorType;
217} // Network
218
219namespace Page {
220class Frame;
221class FrameResource;
222class FrameResourceTree;
223class SearchResult;
224class Cookie;
225enum class Setting;
226enum class ResourceType;
227enum class CoordinateSystem;
228enum class CookieSameSitePolicy;
229#if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
230enum class Appearance;
231#endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
232} // Page
233
234namespace Recording {
235class InitialState;
236class Frame;
237class Recording;
238enum class Type;
239enum class Initiator;
240} // Recording
241
242namespace Runtime {
243class RemoteObject;
244class ObjectPreview;
245class PropertyPreview;
246class EntryPreview;
247class CollectionEntry;
248class PropertyDescriptor;
249class InternalPropertyDescriptor;
250class CallArgument;
251class ExecutionContextDescription;
252class ErrorRange;
253class StructureDescription;
254class TypeSet;
255class TypeDescription;
256class TypeLocation;
257class BasicBlock;
258enum class ExecutionContextType;
259enum class SyntaxErrorType;
260} // Runtime
261
262namespace ScriptProfiler {
263class Event;
264class ExpressionLocation;
265class StackFrame;
266class StackTrace;
267class Samples;
268enum class EventType;
269} // ScriptProfiler
270
271namespace Security {
272class Connection;
273class Certificate;
274class Security;
275} // Security
276
277#if defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER
278namespace ServiceWorker {
279class Configuration;
280} // ServiceWorker
281#endif // defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER
282
283namespace Target {
284class TargetInfo;
285} // Target
286
287namespace Timeline {
288class TimelineEvent;
289enum class EventType;
290enum class Instrument;
291} // Timeline
292// End of forward declarations.
293
294
295// Typedefs.
296namespace Animation {
297/* Unique Web Animation identifier. */
298using AnimationId = String;
299} // Animation
300
301namespace Browser {
302/* Unique extension identifier. */
303using ExtensionId = String;
304} // Browser
305
306namespace CSS {
307using StyleSheetId = String;
308} // CSS
309
310namespace Canvas {
311/* Unique canvas identifier. */
312using CanvasId = String;
313#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
314/* Unique shader program identifier. */
315using ProgramId = String;
316#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
317} // Canvas
318
319namespace DOM {
320/* Unique DOM node identifier. */
321using NodeId = int;
322/* Unique event listener identifier. */
323using EventListenerId = int;
324/* An array of quad vertices, x immediately followed by y for each point, points clock-wise. */
325using Quad = JSON::ArrayOf<double>;
326} // DOM
327
328namespace DOMStorage {
329/* DOM Storage item. */
330using Item = JSON::ArrayOf<String>;
331} // DOMStorage
332
333namespace Database {
334/* Unique identifier of Database object. */
335using DatabaseId = String;
336} // Database
337
338namespace Debugger {
339/* Breakpoint identifier. */
340using BreakpointId = String;
341/* Breakpoint action identifier. */
342using BreakpointActionIdentifier = int;
343/* Unique script identifier. */
344using ScriptId = String;
345/* Call frame identifier. */
346using CallFrameId = String;
347} // Debugger
348
349namespace Heap {
350/* JavaScriptCore HeapSnapshot JSON data. */
351using HeapSnapshotData = String;
352} // Heap
353
354namespace LayerTree {
355/* Unique RenderLayer identifier. */
356using LayerId = String;
357/* Unique PseudoElement identifier. */
358using PseudoElementId = String;
359} // LayerTree
360
361namespace Network {
362/* Unique loader identifier. */
363using LoaderId = String;
364/* Unique frame identifier. */
365using FrameId = String;
366/* Unique request identifier. */
367using RequestId = String;
368/* Elapsed seconds since frontend connected. */
369using Timestamp = double;
370/* Number of seconds since epoch. */
371using Walltime = double;
372} // Network
373
374namespace Runtime {
375/* Unique object identifier. */
376using RemoteObjectId = String;
377/* Id of an execution context. */
378using ExecutionContextId = int;
379} // Runtime
380// End of typedefs.
381
382namespace Helpers {
383
384JS_EXPORT_PRIVATE String getEnumConstantValue(int code);
385
386template<typename T> String getEnumConstantValue(T enumValue)
387{
388 return getEnumConstantValue(static_cast<int>(enumValue));
389}
390
391} // namespace Helpers
392
393namespace Animation {
394
395enum class AnimationState {
396 Ready = 0,
397 Delayed = 1,
398 Active = 2,
399 Canceled = 3,
400 Done = 4,
401}; // enum class AnimationState
402
403enum class PlaybackDirection {
404 Normal = 5,
405 Reverse = 6,
406 Alternate = 7,
407 AlternateReverse = 8,
408}; // enum class PlaybackDirection
409
410enum class FillMode {
411 None = 9,
412 Forwards = 10,
413 Backwards = 11,
414 Both = 12,
415 Auto = 13,
416}; // enum class FillMode
417
418class Animation final : public JSON::ObjectBase {
419public:
420 enum {
421 NoFieldsSet = 0,
422 AnimationIdSet = 1 << 0,
423 AllFieldsSet = (AnimationIdSet)
424 };
425
426 template<int STATE>
427 class Builder {
428 private:
429 RefPtr<JSON::Object> m_result;
430
431 template<int STEP> Builder<STATE | STEP>& castState()
432 {
433 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
434 }
435
436 Builder(Ref</*Animation*/JSON::Object>&& object)
437 : m_result(WTFMove(object))
438 {
439 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
440 }
441 friend class Animation;
442 public:
443
444 Builder<STATE | AnimationIdSet>& setAnimationId(const String& in_animationId)
445 {
446 COMPILE_ASSERT(!(STATE & AnimationIdSet), property_animationId_already_set);
447 m_result->setString("animationId"_s, in_animationId);
448 return castState<AnimationIdSet>();
449 }
450
451 Ref<Animation> release()
452 {
453 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
454 COMPILE_ASSERT(sizeof(Animation) == sizeof(JSON::Object), cannot_cast);
455
456 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
457 auto result = WTFMove(*reinterpret_cast<Ref<Animation>*>(&jsonResult));
458 return result;
459 }
460 };
461
462 /*
463 * Synthetic constructor:
464 * Ref<Animation> result = Animation::create()
465 * .setAnimationId(...)
466 * .release();
467 */
468 static Builder<NoFieldsSet> create()
469 {
470 return Builder<NoFieldsSet>(JSON::Object::create());
471 }
472
473 void setName(const String& in_opt_name)
474 {
475 JSON::ObjectBase::setString("name"_s, in_opt_name);
476 }
477
478 void setCssAnimationName(const String& in_opt_cssAnimationName)
479 {
480 JSON::ObjectBase::setString("cssAnimationName"_s, in_opt_cssAnimationName);
481 }
482
483 void setCssTransitionProperty(const String& in_opt_cssTransitionProperty)
484 {
485 JSON::ObjectBase::setString("cssTransitionProperty"_s, in_opt_cssTransitionProperty);
486 }
487
488 void setEffect(Ref<Protocol::Animation::Effect>&& in_opt_effect)
489 {
490 JSON::ObjectBase::setObject("effect"_s, WTFMove(in_opt_effect));
491 }
492
493 void setBacktrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_backtrace)
494 {
495 JSON::ObjectBase::setArray("backtrace"_s, WTFMove(in_opt_backtrace));
496 }
497};
498
499class Effect final : public JSON::ObjectBase {
500public:
501 enum {
502 NoFieldsSet = 0,
503 AllFieldsSet = 0
504 };
505
506 template<int STATE>
507 class Builder {
508 private:
509 RefPtr<JSON::Object> m_result;
510
511 template<int STEP> Builder<STATE | STEP>& castState()
512 {
513 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
514 }
515
516 Builder(Ref</*Effect*/JSON::Object>&& object)
517 : m_result(WTFMove(object))
518 {
519 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
520 }
521 friend class Effect;
522 public:
523
524 Ref<Effect> release()
525 {
526 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
527 COMPILE_ASSERT(sizeof(Effect) == sizeof(JSON::Object), cannot_cast);
528
529 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
530 auto result = WTFMove(*reinterpret_cast<Ref<Effect>*>(&jsonResult));
531 return result;
532 }
533 };
534
535 /*
536 * Synthetic constructor:
537 * Ref<Effect> result = Effect::create()
538 * .release();
539 */
540 static Builder<NoFieldsSet> create()
541 {
542 return Builder<NoFieldsSet>(JSON::Object::create());
543 }
544
545 void setStartDelay(double in_opt_startDelay)
546 {
547 JSON::ObjectBase::setDouble("startDelay"_s, in_opt_startDelay);
548 }
549
550 void setEndDelay(double in_opt_endDelay)
551 {
552 JSON::ObjectBase::setDouble("endDelay"_s, in_opt_endDelay);
553 }
554
555 void setIterationCount(double in_opt_iterationCount)
556 {
557 JSON::ObjectBase::setDouble("iterationCount"_s, in_opt_iterationCount);
558 }
559
560 void setIterationStart(double in_opt_iterationStart)
561 {
562 JSON::ObjectBase::setDouble("iterationStart"_s, in_opt_iterationStart);
563 }
564
565 void setIterationDuration(double in_opt_iterationDuration)
566 {
567 JSON::ObjectBase::setDouble("iterationDuration"_s, in_opt_iterationDuration);
568 }
569
570 void setTimingFunction(const String& in_opt_timingFunction)
571 {
572 JSON::ObjectBase::setString("timingFunction"_s, in_opt_timingFunction);
573 }
574
575 void setPlaybackDirection(Protocol::Animation::PlaybackDirection in_opt_playbackDirection)
576 {
577 JSON::ObjectBase::setString("playbackDirection"_s, Protocol::Helpers::getEnumConstantValue(in_opt_playbackDirection));
578 }
579
580 void setFillMode(Protocol::Animation::FillMode in_opt_fillMode)
581 {
582 JSON::ObjectBase::setString("fillMode"_s, Protocol::Helpers::getEnumConstantValue(in_opt_fillMode));
583 }
584
585 void setKeyframes(Ref<JSON::ArrayOf<Protocol::Animation::Keyframe>>&& in_opt_keyframes)
586 {
587 JSON::ObjectBase::setArray("keyframes"_s, WTFMove(in_opt_keyframes));
588 }
589};
590
591class Keyframe final : public JSON::ObjectBase {
592public:
593 enum {
594 NoFieldsSet = 0,
595 OffsetSet = 1 << 0,
596 AllFieldsSet = (OffsetSet)
597 };
598
599 template<int STATE>
600 class Builder {
601 private:
602 RefPtr<JSON::Object> m_result;
603
604 template<int STEP> Builder<STATE | STEP>& castState()
605 {
606 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
607 }
608
609 Builder(Ref</*Keyframe*/JSON::Object>&& object)
610 : m_result(WTFMove(object))
611 {
612 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
613 }
614 friend class Keyframe;
615 public:
616
617 Builder<STATE | OffsetSet>& setOffset(double in_offset)
618 {
619 COMPILE_ASSERT(!(STATE & OffsetSet), property_offset_already_set);
620 m_result->setDouble("offset"_s, in_offset);
621 return castState<OffsetSet>();
622 }
623
624 Ref<Keyframe> release()
625 {
626 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
627 COMPILE_ASSERT(sizeof(Keyframe) == sizeof(JSON::Object), cannot_cast);
628
629 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
630 auto result = WTFMove(*reinterpret_cast<Ref<Keyframe>*>(&jsonResult));
631 return result;
632 }
633 };
634
635 /*
636 * Synthetic constructor:
637 * Ref<Keyframe> result = Keyframe::create()
638 * .setOffset(...)
639 * .release();
640 */
641 static Builder<NoFieldsSet> create()
642 {
643 return Builder<NoFieldsSet>(JSON::Object::create());
644 }
645
646 void setEasing(const String& in_opt_easing)
647 {
648 JSON::ObjectBase::setString("easing"_s, in_opt_easing);
649 }
650
651 void setStyle(const String& in_opt_style)
652 {
653 JSON::ObjectBase::setString("style"_s, in_opt_style);
654 }
655};
656
657class TrackingUpdate final : public JSON::ObjectBase {
658public:
659 enum {
660 NoFieldsSet = 0,
661 TrackingAnimationIdSet = 1 << 0,
662 AnimationStateSet = 1 << 1,
663 AllFieldsSet = (TrackingAnimationIdSet | AnimationStateSet)
664 };
665
666 template<int STATE>
667 class Builder {
668 private:
669 RefPtr<JSON::Object> m_result;
670
671 template<int STEP> Builder<STATE | STEP>& castState()
672 {
673 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
674 }
675
676 Builder(Ref</*TrackingUpdate*/JSON::Object>&& object)
677 : m_result(WTFMove(object))
678 {
679 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
680 }
681 friend class TrackingUpdate;
682 public:
683
684 Builder<STATE | TrackingAnimationIdSet>& setTrackingAnimationId(const String& in_trackingAnimationId)
685 {
686 COMPILE_ASSERT(!(STATE & TrackingAnimationIdSet), property_trackingAnimationId_already_set);
687 m_result->setString("trackingAnimationId"_s, in_trackingAnimationId);
688 return castState<TrackingAnimationIdSet>();
689 }
690
691 Builder<STATE | AnimationStateSet>& setAnimationState(Protocol::Animation::AnimationState in_animationState)
692 {
693 COMPILE_ASSERT(!(STATE & AnimationStateSet), property_animationState_already_set);
694 m_result->setString("animationState"_s, Protocol::Helpers::getEnumConstantValue(in_animationState));
695 return castState<AnimationStateSet>();
696 }
697
698 Ref<TrackingUpdate> release()
699 {
700 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
701 COMPILE_ASSERT(sizeof(TrackingUpdate) == sizeof(JSON::Object), cannot_cast);
702
703 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
704 auto result = WTFMove(*reinterpret_cast<Ref<TrackingUpdate>*>(&jsonResult));
705 return result;
706 }
707 };
708
709 /*
710 * Synthetic constructor:
711 * Ref<TrackingUpdate> result = TrackingUpdate::create()
712 * .setTrackingAnimationId(...)
713 * .setAnimationState(...)
714 * .release();
715 */
716 static Builder<NoFieldsSet> create()
717 {
718 return Builder<NoFieldsSet>(JSON::Object::create());
719 }
720
721 void setNodeId(int in_opt_nodeId)
722 {
723 JSON::ObjectBase::setInteger("nodeId"_s, in_opt_nodeId);
724 }
725
726 void setAnimationName(const String& in_opt_animationName)
727 {
728 JSON::ObjectBase::setString("animationName"_s, in_opt_animationName);
729 }
730
731 void setTransitionProperty(const String& in_opt_transitionProperty)
732 {
733 JSON::ObjectBase::setString("transitionProperty"_s, in_opt_transitionProperty);
734 }
735};
736
737} // Animation
738
739namespace ApplicationCache {
740
741/* Detailed application cache resource information. */
742class ApplicationCacheResource final : public JSON::ObjectBase {
743public:
744 enum {
745 NoFieldsSet = 0,
746 UrlSet = 1 << 0,
747 SizeSet = 1 << 1,
748 TypeSet = 1 << 2,
749 AllFieldsSet = (UrlSet | SizeSet | TypeSet)
750 };
751
752 template<int STATE>
753 class Builder {
754 private:
755 RefPtr<JSON::Object> m_result;
756
757 template<int STEP> Builder<STATE | STEP>& castState()
758 {
759 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
760 }
761
762 Builder(Ref</*ApplicationCacheResource*/JSON::Object>&& object)
763 : m_result(WTFMove(object))
764 {
765 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
766 }
767 friend class ApplicationCacheResource;
768 public:
769
770 Builder<STATE | UrlSet>& setUrl(const String& in_url)
771 {
772 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
773 m_result->setString("url"_s, in_url);
774 return castState<UrlSet>();
775 }
776
777 Builder<STATE | SizeSet>& setSize(int in_size)
778 {
779 COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
780 m_result->setInteger("size"_s, in_size);
781 return castState<SizeSet>();
782 }
783
784 Builder<STATE | TypeSet>& setType(const String& in_type)
785 {
786 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
787 m_result->setString("type"_s, in_type);
788 return castState<TypeSet>();
789 }
790
791 Ref<ApplicationCacheResource> release()
792 {
793 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
794 COMPILE_ASSERT(sizeof(ApplicationCacheResource) == sizeof(JSON::Object), cannot_cast);
795
796 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
797 auto result = WTFMove(*reinterpret_cast<Ref<ApplicationCacheResource>*>(&jsonResult));
798 return result;
799 }
800 };
801
802 /*
803 * Synthetic constructor:
804 * Ref<ApplicationCacheResource> result = ApplicationCacheResource::create()
805 * .setUrl(...)
806 * .setSize(...)
807 * .setType(...)
808 * .release();
809 */
810 static Builder<NoFieldsSet> create()
811 {
812 return Builder<NoFieldsSet>(JSON::Object::create());
813 }
814};
815
816/* Detailed application cache information. */
817class ApplicationCache final : public JSON::ObjectBase {
818public:
819 enum {
820 NoFieldsSet = 0,
821 ManifestURLSet = 1 << 0,
822 SizeSet = 1 << 1,
823 CreationTimeSet = 1 << 2,
824 UpdateTimeSet = 1 << 3,
825 ResourcesSet = 1 << 4,
826 AllFieldsSet = (ManifestURLSet | SizeSet | CreationTimeSet | UpdateTimeSet | ResourcesSet)
827 };
828
829 template<int STATE>
830 class Builder {
831 private:
832 RefPtr<JSON::Object> m_result;
833
834 template<int STEP> Builder<STATE | STEP>& castState()
835 {
836 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
837 }
838
839 Builder(Ref</*ApplicationCache*/JSON::Object>&& object)
840 : m_result(WTFMove(object))
841 {
842 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
843 }
844 friend class ApplicationCache;
845 public:
846
847 Builder<STATE | ManifestURLSet>& setManifestURL(const String& in_manifestURL)
848 {
849 COMPILE_ASSERT(!(STATE & ManifestURLSet), property_manifestURL_already_set);
850 m_result->setString("manifestURL"_s, in_manifestURL);
851 return castState<ManifestURLSet>();
852 }
853
854 Builder<STATE | SizeSet>& setSize(double in_size)
855 {
856 COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
857 m_result->setDouble("size"_s, in_size);
858 return castState<SizeSet>();
859 }
860
861 Builder<STATE | CreationTimeSet>& setCreationTime(double in_creationTime)
862 {
863 COMPILE_ASSERT(!(STATE & CreationTimeSet), property_creationTime_already_set);
864 m_result->setDouble("creationTime"_s, in_creationTime);
865 return castState<CreationTimeSet>();
866 }
867
868 Builder<STATE | UpdateTimeSet>& setUpdateTime(double in_updateTime)
869 {
870 COMPILE_ASSERT(!(STATE & UpdateTimeSet), property_updateTime_already_set);
871 m_result->setDouble("updateTime"_s, in_updateTime);
872 return castState<UpdateTimeSet>();
873 }
874
875 Builder<STATE | ResourcesSet>& setResources(Ref<JSON::ArrayOf<Protocol::ApplicationCache::ApplicationCacheResource>>&& in_resources)
876 {
877 COMPILE_ASSERT(!(STATE & ResourcesSet), property_resources_already_set);
878 m_result->setArray("resources"_s, WTFMove(in_resources));
879 return castState<ResourcesSet>();
880 }
881
882 Ref<ApplicationCache> release()
883 {
884 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
885 COMPILE_ASSERT(sizeof(ApplicationCache) == sizeof(JSON::Object), cannot_cast);
886
887 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
888 auto result = WTFMove(*reinterpret_cast<Ref<ApplicationCache>*>(&jsonResult));
889 return result;
890 }
891 };
892
893 /*
894 * Synthetic constructor:
895 * Ref<ApplicationCache> result = ApplicationCache::create()
896 * .setManifestURL(...)
897 * .setSize(...)
898 * .setCreationTime(...)
899 * .setUpdateTime(...)
900 * .setResources(...)
901 * .release();
902 */
903 static Builder<NoFieldsSet> create()
904 {
905 return Builder<NoFieldsSet>(JSON::Object::create());
906 }
907};
908
909/* Frame identifier - manifest URL pair. */
910class FrameWithManifest final : public JSON::ObjectBase {
911public:
912 enum {
913 NoFieldsSet = 0,
914 FrameIdSet = 1 << 0,
915 ManifestURLSet = 1 << 1,
916 StatusSet = 1 << 2,
917 AllFieldsSet = (FrameIdSet | ManifestURLSet | StatusSet)
918 };
919
920 template<int STATE>
921 class Builder {
922 private:
923 RefPtr<JSON::Object> m_result;
924
925 template<int STEP> Builder<STATE | STEP>& castState()
926 {
927 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
928 }
929
930 Builder(Ref</*FrameWithManifest*/JSON::Object>&& object)
931 : m_result(WTFMove(object))
932 {
933 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
934 }
935 friend class FrameWithManifest;
936 public:
937
938 Builder<STATE | FrameIdSet>& setFrameId(const String& in_frameId)
939 {
940 COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
941 m_result->setString("frameId"_s, in_frameId);
942 return castState<FrameIdSet>();
943 }
944
945 Builder<STATE | ManifestURLSet>& setManifestURL(const String& in_manifestURL)
946 {
947 COMPILE_ASSERT(!(STATE & ManifestURLSet), property_manifestURL_already_set);
948 m_result->setString("manifestURL"_s, in_manifestURL);
949 return castState<ManifestURLSet>();
950 }
951
952 Builder<STATE | StatusSet>& setStatus(int in_status)
953 {
954 COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
955 m_result->setInteger("status"_s, in_status);
956 return castState<StatusSet>();
957 }
958
959 Ref<FrameWithManifest> release()
960 {
961 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
962 COMPILE_ASSERT(sizeof(FrameWithManifest) == sizeof(JSON::Object), cannot_cast);
963
964 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
965 auto result = WTFMove(*reinterpret_cast<Ref<FrameWithManifest>*>(&jsonResult));
966 return result;
967 }
968 };
969
970 /*
971 * Synthetic constructor:
972 * Ref<FrameWithManifest> result = FrameWithManifest::create()
973 * .setFrameId(...)
974 * .setManifestURL(...)
975 * .setStatus(...)
976 * .release();
977 */
978 static Builder<NoFieldsSet> create()
979 {
980 return Builder<NoFieldsSet>(JSON::Object::create());
981 }
982};
983
984} // ApplicationCache
985
986namespace Browser {
987
988/* Information about an extension. */
989class Extension final : public JSON::ObjectBase {
990public:
991 enum {
992 NoFieldsSet = 0,
993 ExtensionIdSet = 1 << 0,
994 NameSet = 1 << 1,
995 AllFieldsSet = (ExtensionIdSet | NameSet)
996 };
997
998 template<int STATE>
999 class Builder {
1000 private:
1001 RefPtr<JSON::Object> m_result;
1002
1003 template<int STEP> Builder<STATE | STEP>& castState()
1004 {
1005 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1006 }
1007
1008 Builder(Ref</*Extension*/JSON::Object>&& object)
1009 : m_result(WTFMove(object))
1010 {
1011 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1012 }
1013 friend class Extension;
1014 public:
1015
1016 Builder<STATE | ExtensionIdSet>& setExtensionId(const String& in_extensionId)
1017 {
1018 COMPILE_ASSERT(!(STATE & ExtensionIdSet), property_extensionId_already_set);
1019 m_result->setString("extensionId"_s, in_extensionId);
1020 return castState<ExtensionIdSet>();
1021 }
1022
1023 Builder<STATE | NameSet>& setName(const String& in_name)
1024 {
1025 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1026 m_result->setString("name"_s, in_name);
1027 return castState<NameSet>();
1028 }
1029
1030 Ref<Extension> release()
1031 {
1032 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1033 COMPILE_ASSERT(sizeof(Extension) == sizeof(JSON::Object), cannot_cast);
1034
1035 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1036 auto result = WTFMove(*reinterpret_cast<Ref<Extension>*>(&jsonResult));
1037 return result;
1038 }
1039 };
1040
1041 /*
1042 * Synthetic constructor:
1043 * Ref<Extension> result = Extension::create()
1044 * .setExtensionId(...)
1045 * .setName(...)
1046 * .release();
1047 */
1048 static Builder<NoFieldsSet> create()
1049 {
1050 return Builder<NoFieldsSet>(JSON::Object::create());
1051 }
1052};
1053
1054} // Browser
1055
1056#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
1057namespace CPUProfiler {
1058
1059/* CPU usage for an individual thread. */
1060class ThreadInfo final : public JSON::ObjectBase {
1061public:
1062 // Named after property name 'type' while generating ThreadInfo.
1063 enum class Type {
1064 Main = 14,
1065 WebKit = 15,
1066 }; // enum class Type
1067
1068 enum {
1069 NoFieldsSet = 0,
1070 NameSet = 1 << 0,
1071 UsageSet = 1 << 1,
1072 AllFieldsSet = (NameSet | UsageSet)
1073 };
1074
1075 template<int STATE>
1076 class Builder {
1077 private:
1078 RefPtr<JSON::Object> m_result;
1079
1080 template<int STEP> Builder<STATE | STEP>& castState()
1081 {
1082 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1083 }
1084
1085 Builder(Ref</*ThreadInfo*/JSON::Object>&& object)
1086 : m_result(WTFMove(object))
1087 {
1088 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1089 }
1090 friend class ThreadInfo;
1091 public:
1092
1093 Builder<STATE | NameSet>& setName(const String& in_name)
1094 {
1095 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1096 m_result->setString("name"_s, in_name);
1097 return castState<NameSet>();
1098 }
1099
1100 Builder<STATE | UsageSet>& setUsage(double in_usage)
1101 {
1102 COMPILE_ASSERT(!(STATE & UsageSet), property_usage_already_set);
1103 m_result->setDouble("usage"_s, in_usage);
1104 return castState<UsageSet>();
1105 }
1106
1107 Ref<ThreadInfo> release()
1108 {
1109 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1110 COMPILE_ASSERT(sizeof(ThreadInfo) == sizeof(JSON::Object), cannot_cast);
1111
1112 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1113 auto result = WTFMove(*reinterpret_cast<Ref<ThreadInfo>*>(&jsonResult));
1114 return result;
1115 }
1116 };
1117
1118 /*
1119 * Synthetic constructor:
1120 * Ref<ThreadInfo> result = ThreadInfo::create()
1121 * .setName(...)
1122 * .setUsage(...)
1123 * .release();
1124 */
1125 static Builder<NoFieldsSet> create()
1126 {
1127 return Builder<NoFieldsSet>(JSON::Object::create());
1128 }
1129
1130 void setType(Type in_opt_type)
1131 {
1132 JSON::ObjectBase::setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_opt_type));
1133 }
1134
1135 void setTargetId(const String& in_opt_targetId)
1136 {
1137 JSON::ObjectBase::setString("targetId"_s, in_opt_targetId);
1138 }
1139};
1140
1141class Event final : public JSON::ObjectBase {
1142public:
1143 enum {
1144 NoFieldsSet = 0,
1145 TimestampSet = 1 << 0,
1146 UsageSet = 1 << 1,
1147 AllFieldsSet = (TimestampSet | UsageSet)
1148 };
1149
1150 template<int STATE>
1151 class Builder {
1152 private:
1153 RefPtr<JSON::Object> m_result;
1154
1155 template<int STEP> Builder<STATE | STEP>& castState()
1156 {
1157 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1158 }
1159
1160 Builder(Ref</*Event*/JSON::Object>&& object)
1161 : m_result(WTFMove(object))
1162 {
1163 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1164 }
1165 friend class Event;
1166 public:
1167
1168 Builder<STATE | TimestampSet>& setTimestamp(double in_timestamp)
1169 {
1170 COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
1171 m_result->setDouble("timestamp"_s, in_timestamp);
1172 return castState<TimestampSet>();
1173 }
1174
1175 Builder<STATE | UsageSet>& setUsage(double in_usage)
1176 {
1177 COMPILE_ASSERT(!(STATE & UsageSet), property_usage_already_set);
1178 m_result->setDouble("usage"_s, in_usage);
1179 return castState<UsageSet>();
1180 }
1181
1182 Ref<Event> release()
1183 {
1184 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1185 COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast);
1186
1187 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1188 auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult));
1189 return result;
1190 }
1191 };
1192
1193 /*
1194 * Synthetic constructor:
1195 * Ref<Event> result = Event::create()
1196 * .setTimestamp(...)
1197 * .setUsage(...)
1198 * .release();
1199 */
1200 static Builder<NoFieldsSet> create()
1201 {
1202 return Builder<NoFieldsSet>(JSON::Object::create());
1203 }
1204
1205 void setThreads(Ref<JSON::ArrayOf<Protocol::CPUProfiler::ThreadInfo>>&& in_opt_threads)
1206 {
1207 JSON::ObjectBase::setArray("threads"_s, WTFMove(in_opt_threads));
1208 }
1209};
1210
1211} // CPUProfiler
1212#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
1213
1214namespace CSS {
1215
1216/* This object identifies a CSS style in a unique way. */
1217class CSSStyleId final : public JSON::ObjectBase {
1218public:
1219 enum {
1220 NoFieldsSet = 0,
1221 StyleSheetIdSet = 1 << 0,
1222 OrdinalSet = 1 << 1,
1223 AllFieldsSet = (StyleSheetIdSet | OrdinalSet)
1224 };
1225
1226 template<int STATE>
1227 class Builder {
1228 private:
1229 RefPtr<JSON::Object> m_result;
1230
1231 template<int STEP> Builder<STATE | STEP>& castState()
1232 {
1233 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1234 }
1235
1236 Builder(Ref</*CSSStyleId*/JSON::Object>&& object)
1237 : m_result(WTFMove(object))
1238 {
1239 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1240 }
1241 friend class CSSStyleId;
1242 public:
1243
1244 Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId)
1245 {
1246 COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1247 m_result->setString("styleSheetId"_s, in_styleSheetId);
1248 return castState<StyleSheetIdSet>();
1249 }
1250
1251 Builder<STATE | OrdinalSet>& setOrdinal(int in_ordinal)
1252 {
1253 COMPILE_ASSERT(!(STATE & OrdinalSet), property_ordinal_already_set);
1254 m_result->setInteger("ordinal"_s, in_ordinal);
1255 return castState<OrdinalSet>();
1256 }
1257
1258 Ref<CSSStyleId> release()
1259 {
1260 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1261 COMPILE_ASSERT(sizeof(CSSStyleId) == sizeof(JSON::Object), cannot_cast);
1262
1263 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1264 auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleId>*>(&jsonResult));
1265 return result;
1266 }
1267 };
1268
1269 /*
1270 * Synthetic constructor:
1271 * Ref<CSSStyleId> result = CSSStyleId::create()
1272 * .setStyleSheetId(...)
1273 * .setOrdinal(...)
1274 * .release();
1275 */
1276 static Builder<NoFieldsSet> create()
1277 {
1278 return Builder<NoFieldsSet>(JSON::Object::create());
1279 }
1280};
1281
1282/* Stylesheet type: "user" for user stylesheets, "user-agent" for user-agent stylesheets, "inspector" for stylesheets created by the inspector (i.e. those holding the "via inspector" rules), "regular" for regular stylesheets. */
1283enum class StyleSheetOrigin {
1284 User = 16,
1285 UserAgent = 17,
1286 Author = 18,
1287 Inspector = 19,
1288}; // enum class StyleSheetOrigin
1289
1290/* This object identifies a CSS rule in a unique way. */
1291class CSSRuleId final : public JSON::ObjectBase {
1292public:
1293 enum {
1294 NoFieldsSet = 0,
1295 StyleSheetIdSet = 1 << 0,
1296 OrdinalSet = 1 << 1,
1297 AllFieldsSet = (StyleSheetIdSet | OrdinalSet)
1298 };
1299
1300 template<int STATE>
1301 class Builder {
1302 private:
1303 RefPtr<JSON::Object> m_result;
1304
1305 template<int STEP> Builder<STATE | STEP>& castState()
1306 {
1307 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1308 }
1309
1310 Builder(Ref</*CSSRuleId*/JSON::Object>&& object)
1311 : m_result(WTFMove(object))
1312 {
1313 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1314 }
1315 friend class CSSRuleId;
1316 public:
1317
1318 Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId)
1319 {
1320 COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1321 m_result->setString("styleSheetId"_s, in_styleSheetId);
1322 return castState<StyleSheetIdSet>();
1323 }
1324
1325 Builder<STATE | OrdinalSet>& setOrdinal(int in_ordinal)
1326 {
1327 COMPILE_ASSERT(!(STATE & OrdinalSet), property_ordinal_already_set);
1328 m_result->setInteger("ordinal"_s, in_ordinal);
1329 return castState<OrdinalSet>();
1330 }
1331
1332 Ref<CSSRuleId> release()
1333 {
1334 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1335 COMPILE_ASSERT(sizeof(CSSRuleId) == sizeof(JSON::Object), cannot_cast);
1336
1337 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1338 auto result = WTFMove(*reinterpret_cast<Ref<CSSRuleId>*>(&jsonResult));
1339 return result;
1340 }
1341 };
1342
1343 /*
1344 * Synthetic constructor:
1345 * Ref<CSSRuleId> result = CSSRuleId::create()
1346 * .setStyleSheetId(...)
1347 * .setOrdinal(...)
1348 * .release();
1349 */
1350 static Builder<NoFieldsSet> create()
1351 {
1352 return Builder<NoFieldsSet>(JSON::Object::create());
1353 }
1354};
1355
1356/* Pseudo-style identifier (see <code>enum PseudoId</code> in <code>RenderStyleConstants.h</code>). */
1357enum class PseudoId {
1358 FirstLine = 20,
1359 FirstLetter = 21,
1360 Highlight = 22,
1361 Marker = 23,
1362 Before = 24,
1363 After = 25,
1364 Selection = 26,
1365 Scrollbar = 27,
1366 ScrollbarThumb = 28,
1367 ScrollbarButton = 29,
1368 ScrollbarTrack = 30,
1369 ScrollbarTrackPiece = 31,
1370 ScrollbarCorner = 32,
1371 Resizer = 33,
1372}; // enum class PseudoId
1373
1374/* CSS rule collection for a single pseudo style. */
1375class PseudoIdMatches final : public JSON::ObjectBase {
1376public:
1377 enum {
1378 NoFieldsSet = 0,
1379 PseudoIdSet = 1 << 0,
1380 MatchesSet = 1 << 1,
1381 AllFieldsSet = (PseudoIdSet | MatchesSet)
1382 };
1383
1384 template<int STATE>
1385 class Builder {
1386 private:
1387 RefPtr<JSON::Object> m_result;
1388
1389 template<int STEP> Builder<STATE | STEP>& castState()
1390 {
1391 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1392 }
1393
1394 Builder(Ref</*PseudoIdMatches*/JSON::Object>&& object)
1395 : m_result(WTFMove(object))
1396 {
1397 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1398 }
1399 friend class PseudoIdMatches;
1400 public:
1401
1402 Builder<STATE | PseudoIdSet>& setPseudoId(Protocol::CSS::PseudoId in_pseudoId)
1403 {
1404 COMPILE_ASSERT(!(STATE & PseudoIdSet), property_pseudoId_already_set);
1405 m_result->setString("pseudoId"_s, Protocol::Helpers::getEnumConstantValue(in_pseudoId));
1406 return castState<PseudoIdSet>();
1407 }
1408
1409 Builder<STATE | MatchesSet>& setMatches(Ref<JSON::ArrayOf<Protocol::CSS::RuleMatch>>&& in_matches)
1410 {
1411 COMPILE_ASSERT(!(STATE & MatchesSet), property_matches_already_set);
1412 m_result->setArray("matches"_s, WTFMove(in_matches));
1413 return castState<MatchesSet>();
1414 }
1415
1416 Ref<PseudoIdMatches> release()
1417 {
1418 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1419 COMPILE_ASSERT(sizeof(PseudoIdMatches) == sizeof(JSON::Object), cannot_cast);
1420
1421 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1422 auto result = WTFMove(*reinterpret_cast<Ref<PseudoIdMatches>*>(&jsonResult));
1423 return result;
1424 }
1425 };
1426
1427 /*
1428 * Synthetic constructor:
1429 * Ref<PseudoIdMatches> result = PseudoIdMatches::create()
1430 * .setPseudoId(...)
1431 * .setMatches(...)
1432 * .release();
1433 */
1434 static Builder<NoFieldsSet> create()
1435 {
1436 return Builder<NoFieldsSet>(JSON::Object::create());
1437 }
1438};
1439
1440/* CSS rule collection for a single pseudo style. */
1441class InheritedStyleEntry final : public JSON::ObjectBase {
1442public:
1443 enum {
1444 NoFieldsSet = 0,
1445 MatchedCSSRulesSet = 1 << 0,
1446 AllFieldsSet = (MatchedCSSRulesSet)
1447 };
1448
1449 template<int STATE>
1450 class Builder {
1451 private:
1452 RefPtr<JSON::Object> m_result;
1453
1454 template<int STEP> Builder<STATE | STEP>& castState()
1455 {
1456 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1457 }
1458
1459 Builder(Ref</*InheritedStyleEntry*/JSON::Object>&& object)
1460 : m_result(WTFMove(object))
1461 {
1462 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1463 }
1464 friend class InheritedStyleEntry;
1465 public:
1466
1467 Builder<STATE | MatchedCSSRulesSet>& setMatchedCSSRules(Ref<JSON::ArrayOf<Protocol::CSS::RuleMatch>>&& in_matchedCSSRules)
1468 {
1469 COMPILE_ASSERT(!(STATE & MatchedCSSRulesSet), property_matchedCSSRules_already_set);
1470 m_result->setArray("matchedCSSRules"_s, WTFMove(in_matchedCSSRules));
1471 return castState<MatchedCSSRulesSet>();
1472 }
1473
1474 Ref<InheritedStyleEntry> release()
1475 {
1476 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1477 COMPILE_ASSERT(sizeof(InheritedStyleEntry) == sizeof(JSON::Object), cannot_cast);
1478
1479 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1480 auto result = WTFMove(*reinterpret_cast<Ref<InheritedStyleEntry>*>(&jsonResult));
1481 return result;
1482 }
1483 };
1484
1485 /*
1486 * Synthetic constructor:
1487 * Ref<InheritedStyleEntry> result = InheritedStyleEntry::create()
1488 * .setMatchedCSSRules(...)
1489 * .release();
1490 */
1491 static Builder<NoFieldsSet> create()
1492 {
1493 return Builder<NoFieldsSet>(JSON::Object::create());
1494 }
1495
1496 void setInlineStyle(Ref<Protocol::CSS::CSSStyle>&& in_opt_inlineStyle)
1497 {
1498 JSON::ObjectBase::setObject("inlineStyle"_s, WTFMove(in_opt_inlineStyle));
1499 }
1500};
1501
1502/* Match data for a CSS rule. */
1503class RuleMatch final : public JSON::ObjectBase {
1504public:
1505 enum {
1506 NoFieldsSet = 0,
1507 RuleSet = 1 << 0,
1508 MatchingSelectorsSet = 1 << 1,
1509 AllFieldsSet = (RuleSet | MatchingSelectorsSet)
1510 };
1511
1512 template<int STATE>
1513 class Builder {
1514 private:
1515 RefPtr<JSON::Object> m_result;
1516
1517 template<int STEP> Builder<STATE | STEP>& castState()
1518 {
1519 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1520 }
1521
1522 Builder(Ref</*RuleMatch*/JSON::Object>&& object)
1523 : m_result(WTFMove(object))
1524 {
1525 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1526 }
1527 friend class RuleMatch;
1528 public:
1529
1530 Builder<STATE | RuleSet>& setRule(Ref<Protocol::CSS::CSSRule>&& in_rule)
1531 {
1532 COMPILE_ASSERT(!(STATE & RuleSet), property_rule_already_set);
1533 m_result->setObject("rule"_s, WTFMove(in_rule));
1534 return castState<RuleSet>();
1535 }
1536
1537 Builder<STATE | MatchingSelectorsSet>& setMatchingSelectors(Ref<JSON::ArrayOf<int>>&& in_matchingSelectors)
1538 {
1539 COMPILE_ASSERT(!(STATE & MatchingSelectorsSet), property_matchingSelectors_already_set);
1540 m_result->setArray("matchingSelectors"_s, WTFMove(in_matchingSelectors));
1541 return castState<MatchingSelectorsSet>();
1542 }
1543
1544 Ref<RuleMatch> release()
1545 {
1546 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1547 COMPILE_ASSERT(sizeof(RuleMatch) == sizeof(JSON::Object), cannot_cast);
1548
1549 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1550 auto result = WTFMove(*reinterpret_cast<Ref<RuleMatch>*>(&jsonResult));
1551 return result;
1552 }
1553 };
1554
1555 /*
1556 * Synthetic constructor:
1557 * Ref<RuleMatch> result = RuleMatch::create()
1558 * .setRule(...)
1559 * .setMatchingSelectors(...)
1560 * .release();
1561 */
1562 static Builder<NoFieldsSet> create()
1563 {
1564 return Builder<NoFieldsSet>(JSON::Object::create());
1565 }
1566};
1567
1568/* CSS selector. */
1569class CSSSelector final : public JSON::ObjectBase {
1570public:
1571 enum {
1572 NoFieldsSet = 0,
1573 TextSet = 1 << 0,
1574 AllFieldsSet = (TextSet)
1575 };
1576
1577 template<int STATE>
1578 class Builder {
1579 private:
1580 RefPtr<JSON::Object> m_result;
1581
1582 template<int STEP> Builder<STATE | STEP>& castState()
1583 {
1584 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1585 }
1586
1587 Builder(Ref</*CSSSelector*/JSON::Object>&& object)
1588 : m_result(WTFMove(object))
1589 {
1590 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1591 }
1592 friend class CSSSelector;
1593 public:
1594
1595 Builder<STATE | TextSet>& setText(const String& in_text)
1596 {
1597 COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
1598 m_result->setString("text"_s, in_text);
1599 return castState<TextSet>();
1600 }
1601
1602 Ref<CSSSelector> release()
1603 {
1604 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1605 COMPILE_ASSERT(sizeof(CSSSelector) == sizeof(JSON::Object), cannot_cast);
1606
1607 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1608 auto result = WTFMove(*reinterpret_cast<Ref<CSSSelector>*>(&jsonResult));
1609 return result;
1610 }
1611 };
1612
1613 /*
1614 * Synthetic constructor:
1615 * Ref<CSSSelector> result = CSSSelector::create()
1616 * .setText(...)
1617 * .release();
1618 */
1619 static Builder<NoFieldsSet> create()
1620 {
1621 return Builder<NoFieldsSet>(JSON::Object::create());
1622 }
1623
1624 void setSpecificity(Ref<JSON::ArrayOf<int>>&& in_opt_specificity)
1625 {
1626 JSON::ObjectBase::setArray("specificity"_s, WTFMove(in_opt_specificity));
1627 }
1628
1629 void setDynamic(bool in_opt_dynamic)
1630 {
1631 JSON::ObjectBase::setBoolean("dynamic"_s, in_opt_dynamic);
1632 }
1633};
1634
1635/* Selector list data. */
1636class SelectorList final : public JSON::ObjectBase {
1637public:
1638 enum {
1639 NoFieldsSet = 0,
1640 SelectorsSet = 1 << 0,
1641 TextSet = 1 << 1,
1642 AllFieldsSet = (SelectorsSet | TextSet)
1643 };
1644
1645 template<int STATE>
1646 class Builder {
1647 private:
1648 RefPtr<JSON::Object> m_result;
1649
1650 template<int STEP> Builder<STATE | STEP>& castState()
1651 {
1652 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1653 }
1654
1655 Builder(Ref</*SelectorList*/JSON::Object>&& object)
1656 : m_result(WTFMove(object))
1657 {
1658 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1659 }
1660 friend class SelectorList;
1661 public:
1662
1663 Builder<STATE | SelectorsSet>& setSelectors(Ref<JSON::ArrayOf<Protocol::CSS::CSSSelector>>&& in_selectors)
1664 {
1665 COMPILE_ASSERT(!(STATE & SelectorsSet), property_selectors_already_set);
1666 m_result->setArray("selectors"_s, WTFMove(in_selectors));
1667 return castState<SelectorsSet>();
1668 }
1669
1670 Builder<STATE | TextSet>& setText(const String& in_text)
1671 {
1672 COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
1673 m_result->setString("text"_s, in_text);
1674 return castState<TextSet>();
1675 }
1676
1677 Ref<SelectorList> release()
1678 {
1679 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1680 COMPILE_ASSERT(sizeof(SelectorList) == sizeof(JSON::Object), cannot_cast);
1681
1682 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1683 auto result = WTFMove(*reinterpret_cast<Ref<SelectorList>*>(&jsonResult));
1684 return result;
1685 }
1686 };
1687
1688 /*
1689 * Synthetic constructor:
1690 * Ref<SelectorList> result = SelectorList::create()
1691 * .setSelectors(...)
1692 * .setText(...)
1693 * .release();
1694 */
1695 static Builder<NoFieldsSet> create()
1696 {
1697 return Builder<NoFieldsSet>(JSON::Object::create());
1698 }
1699
1700 void setRange(Ref<Protocol::CSS::SourceRange>&& in_opt_range)
1701 {
1702 JSON::ObjectBase::setObject("range"_s, WTFMove(in_opt_range));
1703 }
1704};
1705
1706/* CSS style information for a DOM style attribute. */
1707class CSSStyleAttribute final : public JSON::ObjectBase {
1708public:
1709 enum {
1710 NoFieldsSet = 0,
1711 NameSet = 1 << 0,
1712 StyleSet = 1 << 1,
1713 AllFieldsSet = (NameSet | StyleSet)
1714 };
1715
1716 template<int STATE>
1717 class Builder {
1718 private:
1719 RefPtr<JSON::Object> m_result;
1720
1721 template<int STEP> Builder<STATE | STEP>& castState()
1722 {
1723 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1724 }
1725
1726 Builder(Ref</*CSSStyleAttribute*/JSON::Object>&& object)
1727 : m_result(WTFMove(object))
1728 {
1729 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1730 }
1731 friend class CSSStyleAttribute;
1732 public:
1733
1734 Builder<STATE | NameSet>& setName(const String& in_name)
1735 {
1736 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1737 m_result->setString("name"_s, in_name);
1738 return castState<NameSet>();
1739 }
1740
1741 Builder<STATE | StyleSet>& setStyle(Ref<Protocol::CSS::CSSStyle>&& in_style)
1742 {
1743 COMPILE_ASSERT(!(STATE & StyleSet), property_style_already_set);
1744 m_result->setObject("style"_s, WTFMove(in_style));
1745 return castState<StyleSet>();
1746 }
1747
1748 Ref<CSSStyleAttribute> release()
1749 {
1750 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1751 COMPILE_ASSERT(sizeof(CSSStyleAttribute) == sizeof(JSON::Object), cannot_cast);
1752
1753 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1754 auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleAttribute>*>(&jsonResult));
1755 return result;
1756 }
1757 };
1758
1759 /*
1760 * Synthetic constructor:
1761 * Ref<CSSStyleAttribute> result = CSSStyleAttribute::create()
1762 * .setName(...)
1763 * .setStyle(...)
1764 * .release();
1765 */
1766 static Builder<NoFieldsSet> create()
1767 {
1768 return Builder<NoFieldsSet>(JSON::Object::create());
1769 }
1770};
1771
1772/* CSS stylesheet meta-information. */
1773class CSSStyleSheetHeader final : public JSON::ObjectBase {
1774public:
1775 enum {
1776 NoFieldsSet = 0,
1777 StyleSheetIdSet = 1 << 0,
1778 FrameIdSet = 1 << 1,
1779 SourceURLSet = 1 << 2,
1780 OriginSet = 1 << 3,
1781 TitleSet = 1 << 4,
1782 DisabledSet = 1 << 5,
1783 IsInlineSet = 1 << 6,
1784 StartLineSet = 1 << 7,
1785 StartColumnSet = 1 << 8,
1786 AllFieldsSet = (StyleSheetIdSet | FrameIdSet | SourceURLSet | OriginSet | TitleSet | DisabledSet | IsInlineSet | StartLineSet | StartColumnSet)
1787 };
1788
1789 template<int STATE>
1790 class Builder {
1791 private:
1792 RefPtr<JSON::Object> m_result;
1793
1794 template<int STEP> Builder<STATE | STEP>& castState()
1795 {
1796 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1797 }
1798
1799 Builder(Ref</*CSSStyleSheetHeader*/JSON::Object>&& object)
1800 : m_result(WTFMove(object))
1801 {
1802 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1803 }
1804 friend class CSSStyleSheetHeader;
1805 public:
1806
1807 Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId)
1808 {
1809 COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1810 m_result->setString("styleSheetId"_s, in_styleSheetId);
1811 return castState<StyleSheetIdSet>();
1812 }
1813
1814 Builder<STATE | FrameIdSet>& setFrameId(const String& in_frameId)
1815 {
1816 COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
1817 m_result->setString("frameId"_s, in_frameId);
1818 return castState<FrameIdSet>();
1819 }
1820
1821 Builder<STATE | SourceURLSet>& setSourceURL(const String& in_sourceURL)
1822 {
1823 COMPILE_ASSERT(!(STATE & SourceURLSet), property_sourceURL_already_set);
1824 m_result->setString("sourceURL"_s, in_sourceURL);
1825 return castState<SourceURLSet>();
1826 }
1827
1828 Builder<STATE | OriginSet>& setOrigin(Protocol::CSS::StyleSheetOrigin in_origin)
1829 {
1830 COMPILE_ASSERT(!(STATE & OriginSet), property_origin_already_set);
1831 m_result->setString("origin"_s, Protocol::Helpers::getEnumConstantValue(in_origin));
1832 return castState<OriginSet>();
1833 }
1834
1835 Builder<STATE | TitleSet>& setTitle(const String& in_title)
1836 {
1837 COMPILE_ASSERT(!(STATE & TitleSet), property_title_already_set);
1838 m_result->setString("title"_s, in_title);
1839 return castState<TitleSet>();
1840 }
1841
1842 Builder<STATE | DisabledSet>& setDisabled(bool in_disabled)
1843 {
1844 COMPILE_ASSERT(!(STATE & DisabledSet), property_disabled_already_set);
1845 m_result->setBoolean("disabled"_s, in_disabled);
1846 return castState<DisabledSet>();
1847 }
1848
1849 Builder<STATE | IsInlineSet>& setIsInline(bool in_isInline)
1850 {
1851 COMPILE_ASSERT(!(STATE & IsInlineSet), property_isInline_already_set);
1852 m_result->setBoolean("isInline"_s, in_isInline);
1853 return castState<IsInlineSet>();
1854 }
1855
1856 Builder<STATE | StartLineSet>& setStartLine(double in_startLine)
1857 {
1858 COMPILE_ASSERT(!(STATE & StartLineSet), property_startLine_already_set);
1859 m_result->setDouble("startLine"_s, in_startLine);
1860 return castState<StartLineSet>();
1861 }
1862
1863 Builder<STATE | StartColumnSet>& setStartColumn(double in_startColumn)
1864 {
1865 COMPILE_ASSERT(!(STATE & StartColumnSet), property_startColumn_already_set);
1866 m_result->setDouble("startColumn"_s, in_startColumn);
1867 return castState<StartColumnSet>();
1868 }
1869
1870 Ref<CSSStyleSheetHeader> release()
1871 {
1872 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1873 COMPILE_ASSERT(sizeof(CSSStyleSheetHeader) == sizeof(JSON::Object), cannot_cast);
1874
1875 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1876 auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleSheetHeader>*>(&jsonResult));
1877 return result;
1878 }
1879 };
1880
1881 /*
1882 * Synthetic constructor:
1883 * Ref<CSSStyleSheetHeader> result = CSSStyleSheetHeader::create()
1884 * .setStyleSheetId(...)
1885 * .setFrameId(...)
1886 * .setSourceURL(...)
1887 * .setOrigin(...)
1888 * .setTitle(...)
1889 * .setDisabled(...)
1890 * .setIsInline(...)
1891 * .setStartLine(...)
1892 * .setStartColumn(...)
1893 * .release();
1894 */
1895 static Builder<NoFieldsSet> create()
1896 {
1897 return Builder<NoFieldsSet>(JSON::Object::create());
1898 }
1899};
1900
1901/* CSS stylesheet contents. */
1902class CSSStyleSheetBody final : public JSON::ObjectBase {
1903public:
1904 enum {
1905 NoFieldsSet = 0,
1906 StyleSheetIdSet = 1 << 0,
1907 RulesSet = 1 << 1,
1908 AllFieldsSet = (StyleSheetIdSet | RulesSet)
1909 };
1910
1911 template<int STATE>
1912 class Builder {
1913 private:
1914 RefPtr<JSON::Object> m_result;
1915
1916 template<int STEP> Builder<STATE | STEP>& castState()
1917 {
1918 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1919 }
1920
1921 Builder(Ref</*CSSStyleSheetBody*/JSON::Object>&& object)
1922 : m_result(WTFMove(object))
1923 {
1924 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1925 }
1926 friend class CSSStyleSheetBody;
1927 public:
1928
1929 Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId)
1930 {
1931 COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1932 m_result->setString("styleSheetId"_s, in_styleSheetId);
1933 return castState<StyleSheetIdSet>();
1934 }
1935
1936 Builder<STATE | RulesSet>& setRules(Ref<JSON::ArrayOf<Protocol::CSS::CSSRule>>&& in_rules)
1937 {
1938 COMPILE_ASSERT(!(STATE & RulesSet), property_rules_already_set);
1939 m_result->setArray("rules"_s, WTFMove(in_rules));
1940 return castState<RulesSet>();
1941 }
1942
1943 Ref<CSSStyleSheetBody> release()
1944 {
1945 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1946 COMPILE_ASSERT(sizeof(CSSStyleSheetBody) == sizeof(JSON::Object), cannot_cast);
1947
1948 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1949 auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleSheetBody>*>(&jsonResult));
1950 return result;
1951 }
1952 };
1953
1954 /*
1955 * Synthetic constructor:
1956 * Ref<CSSStyleSheetBody> result = CSSStyleSheetBody::create()
1957 * .setStyleSheetId(...)
1958 * .setRules(...)
1959 * .release();
1960 */
1961 static Builder<NoFieldsSet> create()
1962 {
1963 return Builder<NoFieldsSet>(JSON::Object::create());
1964 }
1965
1966 void setText(const String& in_opt_text)
1967 {
1968 JSON::ObjectBase::setString("text"_s, in_opt_text);
1969 }
1970};
1971
1972/* CSS rule representation. */
1973class CSSRule final : public JSON::ObjectBase {
1974public:
1975 enum {
1976 NoFieldsSet = 0,
1977 SelectorListSet = 1 << 0,
1978 SourceLineSet = 1 << 1,
1979 OriginSet = 1 << 2,
1980 StyleSet = 1 << 3,
1981 AllFieldsSet = (SelectorListSet | SourceLineSet | OriginSet | StyleSet)
1982 };
1983
1984 template<int STATE>
1985 class Builder {
1986 private:
1987 RefPtr<JSON::Object> m_result;
1988
1989 template<int STEP> Builder<STATE | STEP>& castState()
1990 {
1991 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1992 }
1993
1994 Builder(Ref</*CSSRule*/JSON::Object>&& object)
1995 : m_result(WTFMove(object))
1996 {
1997 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1998 }
1999 friend class CSSRule;
2000 public:
2001
2002 Builder<STATE | SelectorListSet>& setSelectorList(Ref<Protocol::CSS::SelectorList>&& in_selectorList)
2003 {
2004 COMPILE_ASSERT(!(STATE & SelectorListSet), property_selectorList_already_set);
2005 m_result->setObject("selectorList"_s, WTFMove(in_selectorList));
2006 return castState<SelectorListSet>();
2007 }
2008
2009 Builder<STATE | SourceLineSet>& setSourceLine(int in_sourceLine)
2010 {
2011 COMPILE_ASSERT(!(STATE & SourceLineSet), property_sourceLine_already_set);
2012 m_result->setInteger("sourceLine"_s, in_sourceLine);
2013 return castState<SourceLineSet>();
2014 }
2015
2016 Builder<STATE | OriginSet>& setOrigin(Protocol::CSS::StyleSheetOrigin in_origin)
2017 {
2018 COMPILE_ASSERT(!(STATE & OriginSet), property_origin_already_set);
2019 m_result->setString("origin"_s, Protocol::Helpers::getEnumConstantValue(in_origin));
2020 return castState<OriginSet>();
2021 }
2022
2023 Builder<STATE | StyleSet>& setStyle(Ref<Protocol::CSS::CSSStyle>&& in_style)
2024 {
2025 COMPILE_ASSERT(!(STATE & StyleSet), property_style_already_set);
2026 m_result->setObject("style"_s, WTFMove(in_style));
2027 return castState<StyleSet>();
2028 }
2029
2030 Ref<CSSRule> release()
2031 {
2032 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2033 COMPILE_ASSERT(sizeof(CSSRule) == sizeof(JSON::Object), cannot_cast);
2034
2035 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2036 auto result = WTFMove(*reinterpret_cast<Ref<CSSRule>*>(&jsonResult));
2037 return result;
2038 }
2039 };
2040
2041 /*
2042 * Synthetic constructor:
2043 * Ref<CSSRule> result = CSSRule::create()
2044 * .setSelectorList(...)
2045 * .setSourceLine(...)
2046 * .setOrigin(...)
2047 * .setStyle(...)
2048 * .release();
2049 */
2050 static Builder<NoFieldsSet> create()
2051 {
2052 return Builder<NoFieldsSet>(JSON::Object::create());
2053 }
2054
2055 void setRuleId(Ref<Protocol::CSS::CSSRuleId>&& in_opt_ruleId)
2056 {
2057 JSON::ObjectBase::setObject("ruleId"_s, WTFMove(in_opt_ruleId));
2058 }
2059
2060 void setSourceURL(const String& in_opt_sourceURL)
2061 {
2062 JSON::ObjectBase::setString("sourceURL"_s, in_opt_sourceURL);
2063 }
2064
2065 void setGroupings(Ref<JSON::ArrayOf<Protocol::CSS::Grouping>>&& in_opt_groupings)
2066 {
2067 JSON::ObjectBase::setArray("groupings"_s, WTFMove(in_opt_groupings));
2068 }
2069};
2070
2071/* Text range within a resource. */
2072class SourceRange final : public JSON::ObjectBase {
2073public:
2074 enum {
2075 NoFieldsSet = 0,
2076 StartLineSet = 1 << 0,
2077 StartColumnSet = 1 << 1,
2078 EndLineSet = 1 << 2,
2079 EndColumnSet = 1 << 3,
2080 AllFieldsSet = (StartLineSet | StartColumnSet | EndLineSet | EndColumnSet)
2081 };
2082
2083 template<int STATE>
2084 class Builder {
2085 private:
2086 RefPtr<JSON::Object> m_result;
2087
2088 template<int STEP> Builder<STATE | STEP>& castState()
2089 {
2090 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2091 }
2092
2093 Builder(Ref</*SourceRange*/JSON::Object>&& object)
2094 : m_result(WTFMove(object))
2095 {
2096 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2097 }
2098 friend class SourceRange;
2099 public:
2100
2101 Builder<STATE | StartLineSet>& setStartLine(int in_startLine)
2102 {
2103 COMPILE_ASSERT(!(STATE & StartLineSet), property_startLine_already_set);
2104 m_result->setInteger("startLine"_s, in_startLine);
2105 return castState<StartLineSet>();
2106 }
2107
2108 Builder<STATE | StartColumnSet>& setStartColumn(int in_startColumn)
2109 {
2110 COMPILE_ASSERT(!(STATE & StartColumnSet), property_startColumn_already_set);
2111 m_result->setInteger("startColumn"_s, in_startColumn);
2112 return castState<StartColumnSet>();
2113 }
2114
2115 Builder<STATE | EndLineSet>& setEndLine(int in_endLine)
2116 {
2117 COMPILE_ASSERT(!(STATE & EndLineSet), property_endLine_already_set);
2118 m_result->setInteger("endLine"_s, in_endLine);
2119 return castState<EndLineSet>();
2120 }
2121
2122 Builder<STATE | EndColumnSet>& setEndColumn(int in_endColumn)
2123 {
2124 COMPILE_ASSERT(!(STATE & EndColumnSet), property_endColumn_already_set);
2125 m_result->setInteger("endColumn"_s, in_endColumn);
2126 return castState<EndColumnSet>();
2127 }
2128
2129 Ref<SourceRange> release()
2130 {
2131 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2132 COMPILE_ASSERT(sizeof(SourceRange) == sizeof(JSON::Object), cannot_cast);
2133
2134 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2135 auto result = WTFMove(*reinterpret_cast<Ref<SourceRange>*>(&jsonResult));
2136 return result;
2137 }
2138 };
2139
2140 /*
2141 * Synthetic constructor:
2142 * Ref<SourceRange> result = SourceRange::create()
2143 * .setStartLine(...)
2144 * .setStartColumn(...)
2145 * .setEndLine(...)
2146 * .setEndColumn(...)
2147 * .release();
2148 */
2149 static Builder<NoFieldsSet> create()
2150 {
2151 return Builder<NoFieldsSet>(JSON::Object::create());
2152 }
2153};
2154
2155class ShorthandEntry final : public JSON::ObjectBase {
2156public:
2157 enum {
2158 NoFieldsSet = 0,
2159 NameSet = 1 << 0,
2160 ValueSet = 1 << 1,
2161 AllFieldsSet = (NameSet | ValueSet)
2162 };
2163
2164 template<int STATE>
2165 class Builder {
2166 private:
2167 RefPtr<JSON::Object> m_result;
2168
2169 template<int STEP> Builder<STATE | STEP>& castState()
2170 {
2171 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2172 }
2173
2174 Builder(Ref</*ShorthandEntry*/JSON::Object>&& object)
2175 : m_result(WTFMove(object))
2176 {
2177 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2178 }
2179 friend class ShorthandEntry;
2180 public:
2181
2182 Builder<STATE | NameSet>& setName(const String& in_name)
2183 {
2184 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
2185 m_result->setString("name"_s, in_name);
2186 return castState<NameSet>();
2187 }
2188
2189 Builder<STATE | ValueSet>& setValue(const String& in_value)
2190 {
2191 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
2192 m_result->setString("value"_s, in_value);
2193 return castState<ValueSet>();
2194 }
2195
2196 Ref<ShorthandEntry> release()
2197 {
2198 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2199 COMPILE_ASSERT(sizeof(ShorthandEntry) == sizeof(JSON::Object), cannot_cast);
2200
2201 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2202 auto result = WTFMove(*reinterpret_cast<Ref<ShorthandEntry>*>(&jsonResult));
2203 return result;
2204 }
2205 };
2206
2207 /*
2208 * Synthetic constructor:
2209 * Ref<ShorthandEntry> result = ShorthandEntry::create()
2210 * .setName(...)
2211 * .setValue(...)
2212 * .release();
2213 */
2214 static Builder<NoFieldsSet> create()
2215 {
2216 return Builder<NoFieldsSet>(JSON::Object::create());
2217 }
2218};
2219
2220class CSSPropertyInfo final : public JSON::ObjectBase {
2221public:
2222 enum {
2223 NoFieldsSet = 0,
2224 NameSet = 1 << 0,
2225 AllFieldsSet = (NameSet)
2226 };
2227
2228 template<int STATE>
2229 class Builder {
2230 private:
2231 RefPtr<JSON::Object> m_result;
2232
2233 template<int STEP> Builder<STATE | STEP>& castState()
2234 {
2235 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2236 }
2237
2238 Builder(Ref</*CSSPropertyInfo*/JSON::Object>&& object)
2239 : m_result(WTFMove(object))
2240 {
2241 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2242 }
2243 friend class CSSPropertyInfo;
2244 public:
2245
2246 Builder<STATE | NameSet>& setName(const String& in_name)
2247 {
2248 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
2249 m_result->setString("name"_s, in_name);
2250 return castState<NameSet>();
2251 }
2252
2253 Ref<CSSPropertyInfo> release()
2254 {
2255 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2256 COMPILE_ASSERT(sizeof(CSSPropertyInfo) == sizeof(JSON::Object), cannot_cast);
2257
2258 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2259 auto result = WTFMove(*reinterpret_cast<Ref<CSSPropertyInfo>*>(&jsonResult));
2260 return result;
2261 }
2262 };
2263
2264 /*
2265 * Synthetic constructor:
2266 * Ref<CSSPropertyInfo> result = CSSPropertyInfo::create()
2267 * .setName(...)
2268 * .release();
2269 */
2270 static Builder<NoFieldsSet> create()
2271 {
2272 return Builder<NoFieldsSet>(JSON::Object::create());
2273 }
2274
2275 void setAliases(Ref<JSON::ArrayOf<String>>&& in_opt_aliases)
2276 {
2277 JSON::ObjectBase::setArray("aliases"_s, WTFMove(in_opt_aliases));
2278 }
2279
2280 void setLonghands(Ref<JSON::ArrayOf<String>>&& in_opt_longhands)
2281 {
2282 JSON::ObjectBase::setArray("longhands"_s, WTFMove(in_opt_longhands));
2283 }
2284
2285 void setValues(Ref<JSON::ArrayOf<String>>&& in_opt_values)
2286 {
2287 JSON::ObjectBase::setArray("values"_s, WTFMove(in_opt_values));
2288 }
2289
2290 void setInherited(bool in_opt_inherited)
2291 {
2292 JSON::ObjectBase::setBoolean("inherited"_s, in_opt_inherited);
2293 }
2294};
2295
2296class CSSComputedStyleProperty final : public JSON::ObjectBase {
2297public:
2298 enum {
2299 NoFieldsSet = 0,
2300 NameSet = 1 << 0,
2301 ValueSet = 1 << 1,
2302 AllFieldsSet = (NameSet | ValueSet)
2303 };
2304
2305 template<int STATE>
2306 class Builder {
2307 private:
2308 RefPtr<JSON::Object> m_result;
2309
2310 template<int STEP> Builder<STATE | STEP>& castState()
2311 {
2312 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2313 }
2314
2315 Builder(Ref</*CSSComputedStyleProperty*/JSON::Object>&& object)
2316 : m_result(WTFMove(object))
2317 {
2318 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2319 }
2320 friend class CSSComputedStyleProperty;
2321 public:
2322
2323 Builder<STATE | NameSet>& setName(const String& in_name)
2324 {
2325 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
2326 m_result->setString("name"_s, in_name);
2327 return castState<NameSet>();
2328 }
2329
2330 Builder<STATE | ValueSet>& setValue(const String& in_value)
2331 {
2332 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
2333 m_result->setString("value"_s, in_value);
2334 return castState<ValueSet>();
2335 }
2336
2337 Ref<CSSComputedStyleProperty> release()
2338 {
2339 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2340 COMPILE_ASSERT(sizeof(CSSComputedStyleProperty) == sizeof(JSON::Object), cannot_cast);
2341
2342 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2343 auto result = WTFMove(*reinterpret_cast<Ref<CSSComputedStyleProperty>*>(&jsonResult));
2344 return result;
2345 }
2346 };
2347
2348 /*
2349 * Synthetic constructor:
2350 * Ref<CSSComputedStyleProperty> result = CSSComputedStyleProperty::create()
2351 * .setName(...)
2352 * .setValue(...)
2353 * .release();
2354 */
2355 static Builder<NoFieldsSet> create()
2356 {
2357 return Builder<NoFieldsSet>(JSON::Object::create());
2358 }
2359};
2360
2361/* CSS style representation. */
2362class CSSStyle final : public JSON::ObjectBase {
2363public:
2364 enum {
2365 NoFieldsSet = 0,
2366 CssPropertiesSet = 1 << 0,
2367 ShorthandEntriesSet = 1 << 1,
2368 AllFieldsSet = (CssPropertiesSet | ShorthandEntriesSet)
2369 };
2370
2371 template<int STATE>
2372 class Builder {
2373 private:
2374 RefPtr<JSON::Object> m_result;
2375
2376 template<int STEP> Builder<STATE | STEP>& castState()
2377 {
2378 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2379 }
2380
2381 Builder(Ref</*CSSStyle*/JSON::Object>&& object)
2382 : m_result(WTFMove(object))
2383 {
2384 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2385 }
2386 friend class CSSStyle;
2387 public:
2388
2389 Builder<STATE | CssPropertiesSet>& setCssProperties(Ref<JSON::ArrayOf<Protocol::CSS::CSSProperty>>&& in_cssProperties)
2390 {
2391 COMPILE_ASSERT(!(STATE & CssPropertiesSet), property_cssProperties_already_set);
2392 m_result->setArray("cssProperties"_s, WTFMove(in_cssProperties));
2393 return castState<CssPropertiesSet>();
2394 }
2395
2396 Builder<STATE | ShorthandEntriesSet>& setShorthandEntries(Ref<JSON::ArrayOf<Protocol::CSS::ShorthandEntry>>&& in_shorthandEntries)
2397 {
2398 COMPILE_ASSERT(!(STATE & ShorthandEntriesSet), property_shorthandEntries_already_set);
2399 m_result->setArray("shorthandEntries"_s, WTFMove(in_shorthandEntries));
2400 return castState<ShorthandEntriesSet>();
2401 }
2402
2403 Ref<CSSStyle> release()
2404 {
2405 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2406 COMPILE_ASSERT(sizeof(CSSStyle) == sizeof(JSON::Object), cannot_cast);
2407
2408 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2409 auto result = WTFMove(*reinterpret_cast<Ref<CSSStyle>*>(&jsonResult));
2410 return result;
2411 }
2412 };
2413
2414 /*
2415 * Synthetic constructor:
2416 * Ref<CSSStyle> result = CSSStyle::create()
2417 * .setCssProperties(...)
2418 * .setShorthandEntries(...)
2419 * .release();
2420 */
2421 static Builder<NoFieldsSet> create()
2422 {
2423 return Builder<NoFieldsSet>(JSON::Object::create());
2424 }
2425
2426 void setStyleId(Ref<Protocol::CSS::CSSStyleId>&& in_opt_styleId)
2427 {
2428 JSON::ObjectBase::setObject("styleId"_s, WTFMove(in_opt_styleId));
2429 }
2430
2431 void setCssText(const String& in_opt_cssText)
2432 {
2433 JSON::ObjectBase::setString("cssText"_s, in_opt_cssText);
2434 }
2435
2436 void setRange(Ref<Protocol::CSS::SourceRange>&& in_opt_range)
2437 {
2438 JSON::ObjectBase::setObject("range"_s, WTFMove(in_opt_range));
2439 }
2440
2441 void setWidth(const String& in_opt_width)
2442 {
2443 JSON::ObjectBase::setString("width"_s, in_opt_width);
2444 }
2445
2446 void setHeight(const String& in_opt_height)
2447 {
2448 JSON::ObjectBase::setString("height"_s, in_opt_height);
2449 }
2450};
2451
2452/* The property status: "active" if the property is effective in the style, "inactive" if the property is overridden by a same-named property in this style later on, "disabled" if the property is disabled by the user, "style" (implied if absent) if the property is reported by the browser rather than by the CSS source parser. */
2453enum class CSSPropertyStatus {
2454 Active = 2,
2455 Inactive = 34,
2456 Disabled = 35,
2457 Style = 36,
2458}; // enum class CSSPropertyStatus
2459
2460/* CSS style effective visual dimensions and source offsets. */
2461class CSSProperty final : public JSON::Object {
2462public:
2463 enum {
2464 NoFieldsSet = 0,
2465 NameSet = 1 << 0,
2466 ValueSet = 1 << 1,
2467 AllFieldsSet = (NameSet | ValueSet)
2468 };
2469
2470 template<int STATE>
2471 class Builder {
2472 private:
2473 RefPtr<JSON::Object> m_result;
2474
2475 template<int STEP> Builder<STATE | STEP>& castState()
2476 {
2477 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2478 }
2479
2480 Builder(Ref</*CSSProperty*/JSON::Object>&& object)
2481 : m_result(WTFMove(object))
2482 {
2483 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2484 }
2485 friend class CSSProperty;
2486 public:
2487
2488 Builder<STATE | NameSet>& setName(const String& in_name)
2489 {
2490 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
2491 m_result->setString("name"_s, in_name);
2492 return castState<NameSet>();
2493 }
2494
2495 Builder<STATE | ValueSet>& setValue(const String& in_value)
2496 {
2497 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
2498 m_result->setString("value"_s, in_value);
2499 return castState<ValueSet>();
2500 }
2501
2502 Ref<CSSProperty> release()
2503 {
2504 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2505 COMPILE_ASSERT(sizeof(CSSProperty) == sizeof(JSON::Object), cannot_cast);
2506
2507 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2508 auto result = WTFMove(*reinterpret_cast<Ref<CSSProperty>*>(&jsonResult));
2509 return result;
2510 }
2511 };
2512
2513 /*
2514 * Synthetic constructor:
2515 * Ref<CSSProperty> result = CSSProperty::create()
2516 * .setName(...)
2517 * .setValue(...)
2518 * .release();
2519 */
2520 static Builder<NoFieldsSet> create()
2521 {
2522 return Builder<NoFieldsSet>(JSON::Object::create());
2523 }
2524
2525 void setPriority(const String& in_opt_priority)
2526 {
2527 JSON::ObjectBase::setString("priority"_s, in_opt_priority);
2528 }
2529
2530 void setImplicit(bool in_opt_implicit)
2531 {
2532 JSON::ObjectBase::setBoolean("implicit"_s, in_opt_implicit);
2533 }
2534
2535 void setText(const String& in_opt_text)
2536 {
2537 JSON::ObjectBase::setString("text"_s, in_opt_text);
2538 }
2539
2540 void setParsedOk(bool in_opt_parsedOk)
2541 {
2542 JSON::ObjectBase::setBoolean("parsedOk"_s, in_opt_parsedOk);
2543 }
2544
2545 void setStatus(Protocol::CSS::CSSPropertyStatus in_opt_status)
2546 {
2547 JSON::ObjectBase::setString("status"_s, Protocol::Helpers::getEnumConstantValue(in_opt_status));
2548 }
2549
2550 void setRange(Ref<Protocol::CSS::SourceRange>&& in_opt_range)
2551 {
2552 JSON::ObjectBase::setObject("range"_s, WTFMove(in_opt_range));
2553 }
2554
2555 // Property names for type generated as open.
2556 JS_EXPORT_PRIVATE static const ASCIILiteral priorityKey;
2557 JS_EXPORT_PRIVATE static const ASCIILiteral parsedOkKey;
2558 JS_EXPORT_PRIVATE static const ASCIILiteral statusKey;
2559};
2560
2561/* CSS @media (as well as other users of media queries, like @import, <style>, <link>, etc.) and @supports descriptor. */
2562class Grouping final : public JSON::ObjectBase {
2563public:
2564 // Named after property name 'type' while generating Grouping.
2565 enum class Type {
2566 MediaRule = 37,
2567 MediaImportRule = 38,
2568 MediaLinkNode = 39,
2569 MediaStyleNode = 40,
2570 SupportsRule = 41,
2571 }; // enum class Type
2572
2573 enum {
2574 NoFieldsSet = 0,
2575 TextSet = 1 << 0,
2576 TypeSet = 1 << 1,
2577 AllFieldsSet = (TextSet | TypeSet)
2578 };
2579
2580 template<int STATE>
2581 class Builder {
2582 private:
2583 RefPtr<JSON::Object> m_result;
2584
2585 template<int STEP> Builder<STATE | STEP>& castState()
2586 {
2587 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2588 }
2589
2590 Builder(Ref</*Grouping*/JSON::Object>&& object)
2591 : m_result(WTFMove(object))
2592 {
2593 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2594 }
2595 friend class Grouping;
2596 public:
2597
2598 Builder<STATE | TextSet>& setText(const String& in_text)
2599 {
2600 COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
2601 m_result->setString("text"_s, in_text);
2602 return castState<TextSet>();
2603 }
2604
2605 Builder<STATE | TypeSet>& setType(Type in_type)
2606 {
2607 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
2608 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
2609 return castState<TypeSet>();
2610 }
2611
2612 Ref<Grouping> release()
2613 {
2614 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2615 COMPILE_ASSERT(sizeof(Grouping) == sizeof(JSON::Object), cannot_cast);
2616
2617 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2618 auto result = WTFMove(*reinterpret_cast<Ref<Grouping>*>(&jsonResult));
2619 return result;
2620 }
2621 };
2622
2623 /*
2624 * Synthetic constructor:
2625 * Ref<Grouping> result = Grouping::create()
2626 * .setText(...)
2627 * .setType(...)
2628 * .release();
2629 */
2630 static Builder<NoFieldsSet> create()
2631 {
2632 return Builder<NoFieldsSet>(JSON::Object::create());
2633 }
2634
2635 void setSourceURL(const String& in_opt_sourceURL)
2636 {
2637 JSON::ObjectBase::setString("sourceURL"_s, in_opt_sourceURL);
2638 }
2639};
2640
2641/* A representation of WebCore::Font. Conceptually this is backed by either a font file on disk or from the network. */
2642class Font final : public JSON::ObjectBase {
2643public:
2644 enum {
2645 NoFieldsSet = 0,
2646 DisplayNameSet = 1 << 0,
2647 VariationAxesSet = 1 << 1,
2648 AllFieldsSet = (DisplayNameSet | VariationAxesSet)
2649 };
2650
2651 template<int STATE>
2652 class Builder {
2653 private:
2654 RefPtr<JSON::Object> m_result;
2655
2656 template<int STEP> Builder<STATE | STEP>& castState()
2657 {
2658 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2659 }
2660
2661 Builder(Ref</*Font*/JSON::Object>&& object)
2662 : m_result(WTFMove(object))
2663 {
2664 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2665 }
2666 friend class Font;
2667 public:
2668
2669 Builder<STATE | DisplayNameSet>& setDisplayName(const String& in_displayName)
2670 {
2671 COMPILE_ASSERT(!(STATE & DisplayNameSet), property_displayName_already_set);
2672 m_result->setString("displayName"_s, in_displayName);
2673 return castState<DisplayNameSet>();
2674 }
2675
2676 Builder<STATE | VariationAxesSet>& setVariationAxes(Ref<JSON::ArrayOf<Protocol::CSS::FontVariationAxis>>&& in_variationAxes)
2677 {
2678 COMPILE_ASSERT(!(STATE & VariationAxesSet), property_variationAxes_already_set);
2679 m_result->setArray("variationAxes"_s, WTFMove(in_variationAxes));
2680 return castState<VariationAxesSet>();
2681 }
2682
2683 Ref<Font> release()
2684 {
2685 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2686 COMPILE_ASSERT(sizeof(Font) == sizeof(JSON::Object), cannot_cast);
2687
2688 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2689 auto result = WTFMove(*reinterpret_cast<Ref<Font>*>(&jsonResult));
2690 return result;
2691 }
2692 };
2693
2694 /*
2695 * Synthetic constructor:
2696 * Ref<Font> result = Font::create()
2697 * .setDisplayName(...)
2698 * .setVariationAxes(...)
2699 * .release();
2700 */
2701 static Builder<NoFieldsSet> create()
2702 {
2703 return Builder<NoFieldsSet>(JSON::Object::create());
2704 }
2705};
2706
2707/* A single variation axis associated with a Font. */
2708class FontVariationAxis final : public JSON::ObjectBase {
2709public:
2710 enum {
2711 NoFieldsSet = 0,
2712 TagSet = 1 << 0,
2713 MinimumValueSet = 1 << 1,
2714 MaximumValueSet = 1 << 2,
2715 DefaultValueSet = 1 << 3,
2716 AllFieldsSet = (TagSet | MinimumValueSet | MaximumValueSet | DefaultValueSet)
2717 };
2718
2719 template<int STATE>
2720 class Builder {
2721 private:
2722 RefPtr<JSON::Object> m_result;
2723
2724 template<int STEP> Builder<STATE | STEP>& castState()
2725 {
2726 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2727 }
2728
2729 Builder(Ref</*FontVariationAxis*/JSON::Object>&& object)
2730 : m_result(WTFMove(object))
2731 {
2732 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2733 }
2734 friend class FontVariationAxis;
2735 public:
2736
2737 Builder<STATE | TagSet>& setTag(const String& in_tag)
2738 {
2739 COMPILE_ASSERT(!(STATE & TagSet), property_tag_already_set);
2740 m_result->setString("tag"_s, in_tag);
2741 return castState<TagSet>();
2742 }
2743
2744 Builder<STATE | MinimumValueSet>& setMinimumValue(double in_minimumValue)
2745 {
2746 COMPILE_ASSERT(!(STATE & MinimumValueSet), property_minimumValue_already_set);
2747 m_result->setDouble("minimumValue"_s, in_minimumValue);
2748 return castState<MinimumValueSet>();
2749 }
2750
2751 Builder<STATE | MaximumValueSet>& setMaximumValue(double in_maximumValue)
2752 {
2753 COMPILE_ASSERT(!(STATE & MaximumValueSet), property_maximumValue_already_set);
2754 m_result->setDouble("maximumValue"_s, in_maximumValue);
2755 return castState<MaximumValueSet>();
2756 }
2757
2758 Builder<STATE | DefaultValueSet>& setDefaultValue(double in_defaultValue)
2759 {
2760 COMPILE_ASSERT(!(STATE & DefaultValueSet), property_defaultValue_already_set);
2761 m_result->setDouble("defaultValue"_s, in_defaultValue);
2762 return castState<DefaultValueSet>();
2763 }
2764
2765 Ref<FontVariationAxis> release()
2766 {
2767 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2768 COMPILE_ASSERT(sizeof(FontVariationAxis) == sizeof(JSON::Object), cannot_cast);
2769
2770 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2771 auto result = WTFMove(*reinterpret_cast<Ref<FontVariationAxis>*>(&jsonResult));
2772 return result;
2773 }
2774 };
2775
2776 /*
2777 * Synthetic constructor:
2778 * Ref<FontVariationAxis> result = FontVariationAxis::create()
2779 * .setTag(...)
2780 * .setMinimumValue(...)
2781 * .setMaximumValue(...)
2782 * .setDefaultValue(...)
2783 * .release();
2784 */
2785 static Builder<NoFieldsSet> create()
2786 {
2787 return Builder<NoFieldsSet>(JSON::Object::create());
2788 }
2789
2790 void setName(const String& in_opt_name)
2791 {
2792 JSON::ObjectBase::setString("name"_s, in_opt_name);
2793 }
2794};
2795
2796/* The layout context type of a node. */
2797enum class LayoutContextType {
2798 Grid = 42,
2799}; // enum class LayoutContextType
2800
2801/* The mode for how layout context type changes are handled (default: <code>Observed</code>). <code>Observed</code> limits handling to those nodes already known to the frontend by other means (generally, this means the node is a visible item in the Elements tab). <code>All</code> informs the frontend of all layout context type changes and all nodes with a known layout context are sent to the frontend. */
2802enum class LayoutContextTypeChangedMode {
2803 Observed = 43,
2804 All = 44,
2805}; // enum class LayoutContextTypeChangedMode
2806
2807} // CSS
2808
2809namespace Canvas {
2810
2811/* The type of rendering context backing the canvas element. */
2812enum class ContextType {
2813 Canvas2D = 45,
2814 BitmapRenderer = 46,
2815 WebGL = 47,
2816 WebGL2 = 48,
2817 WebGPU = 49,
2818}; // enum class ContextType
2819
2820#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
2821enum class ProgramType {
2822 Compute = 50,
2823 Render = 51,
2824}; // enum class ProgramType
2825#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
2826
2827#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
2828enum class ShaderType {
2829 Compute = 50,
2830 Fragment = 52,
2831 Vertex = 53,
2832}; // enum class ShaderType
2833#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
2834
2835/* Drawing surface attributes. */
2836class ContextAttributes final : public JSON::ObjectBase {
2837public:
2838 enum {
2839 NoFieldsSet = 0,
2840 AllFieldsSet = 0
2841 };
2842
2843 template<int STATE>
2844 class Builder {
2845 private:
2846 RefPtr<JSON::Object> m_result;
2847
2848 template<int STEP> Builder<STATE | STEP>& castState()
2849 {
2850 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2851 }
2852
2853 Builder(Ref</*ContextAttributes*/JSON::Object>&& object)
2854 : m_result(WTFMove(object))
2855 {
2856 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2857 }
2858 friend class ContextAttributes;
2859 public:
2860
2861 Ref<ContextAttributes> release()
2862 {
2863 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2864 COMPILE_ASSERT(sizeof(ContextAttributes) == sizeof(JSON::Object), cannot_cast);
2865
2866 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2867 auto result = WTFMove(*reinterpret_cast<Ref<ContextAttributes>*>(&jsonResult));
2868 return result;
2869 }
2870 };
2871
2872 /*
2873 * Synthetic constructor:
2874 * Ref<ContextAttributes> result = ContextAttributes::create()
2875 * .release();
2876 */
2877 static Builder<NoFieldsSet> create()
2878 {
2879 return Builder<NoFieldsSet>(JSON::Object::create());
2880 }
2881
2882 void setAlpha(bool in_opt_alpha)
2883 {
2884 JSON::ObjectBase::setBoolean("alpha"_s, in_opt_alpha);
2885 }
2886
2887 void setDepth(bool in_opt_depth)
2888 {
2889 JSON::ObjectBase::setBoolean("depth"_s, in_opt_depth);
2890 }
2891
2892 void setStencil(bool in_opt_stencil)
2893 {
2894 JSON::ObjectBase::setBoolean("stencil"_s, in_opt_stencil);
2895 }
2896
2897 void setAntialias(bool in_opt_antialias)
2898 {
2899 JSON::ObjectBase::setBoolean("antialias"_s, in_opt_antialias);
2900 }
2901
2902 void setPremultipliedAlpha(bool in_opt_premultipliedAlpha)
2903 {
2904 JSON::ObjectBase::setBoolean("premultipliedAlpha"_s, in_opt_premultipliedAlpha);
2905 }
2906
2907 void setPreserveDrawingBuffer(bool in_opt_preserveDrawingBuffer)
2908 {
2909 JSON::ObjectBase::setBoolean("preserveDrawingBuffer"_s, in_opt_preserveDrawingBuffer);
2910 }
2911
2912 void setFailIfMajorPerformanceCaveat(bool in_opt_failIfMajorPerformanceCaveat)
2913 {
2914 JSON::ObjectBase::setBoolean("failIfMajorPerformanceCaveat"_s, in_opt_failIfMajorPerformanceCaveat);
2915 }
2916
2917 void setPowerPreference(const String& in_opt_powerPreference)
2918 {
2919 JSON::ObjectBase::setString("powerPreference"_s, in_opt_powerPreference);
2920 }
2921};
2922
2923/* Information about a canvas for which a rendering context has been created. */
2924class Canvas final : public JSON::ObjectBase {
2925public:
2926 enum {
2927 NoFieldsSet = 0,
2928 CanvasIdSet = 1 << 0,
2929 ContextTypeSet = 1 << 1,
2930 AllFieldsSet = (CanvasIdSet | ContextTypeSet)
2931 };
2932
2933 template<int STATE>
2934 class Builder {
2935 private:
2936 RefPtr<JSON::Object> m_result;
2937
2938 template<int STEP> Builder<STATE | STEP>& castState()
2939 {
2940 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2941 }
2942
2943 Builder(Ref</*Canvas*/JSON::Object>&& object)
2944 : m_result(WTFMove(object))
2945 {
2946 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2947 }
2948 friend class Canvas;
2949 public:
2950
2951 Builder<STATE | CanvasIdSet>& setCanvasId(const String& in_canvasId)
2952 {
2953 COMPILE_ASSERT(!(STATE & CanvasIdSet), property_canvasId_already_set);
2954 m_result->setString("canvasId"_s, in_canvasId);
2955 return castState<CanvasIdSet>();
2956 }
2957
2958 Builder<STATE | ContextTypeSet>& setContextType(Protocol::Canvas::ContextType in_contextType)
2959 {
2960 COMPILE_ASSERT(!(STATE & ContextTypeSet), property_contextType_already_set);
2961 m_result->setString("contextType"_s, Protocol::Helpers::getEnumConstantValue(in_contextType));
2962 return castState<ContextTypeSet>();
2963 }
2964
2965 Ref<Canvas> release()
2966 {
2967 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2968 COMPILE_ASSERT(sizeof(Canvas) == sizeof(JSON::Object), cannot_cast);
2969
2970 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2971 auto result = WTFMove(*reinterpret_cast<Ref<Canvas>*>(&jsonResult));
2972 return result;
2973 }
2974 };
2975
2976 /*
2977 * Synthetic constructor:
2978 * Ref<Canvas> result = Canvas::create()
2979 * .setCanvasId(...)
2980 * .setContextType(...)
2981 * .release();
2982 */
2983 static Builder<NoFieldsSet> create()
2984 {
2985 return Builder<NoFieldsSet>(JSON::Object::create());
2986 }
2987
2988 void setNodeId(int in_opt_nodeId)
2989 {
2990 JSON::ObjectBase::setInteger("nodeId"_s, in_opt_nodeId);
2991 }
2992
2993 void setCssCanvasName(const String& in_opt_cssCanvasName)
2994 {
2995 JSON::ObjectBase::setString("cssCanvasName"_s, in_opt_cssCanvasName);
2996 }
2997
2998 void setContextAttributes(Ref<Protocol::Canvas::ContextAttributes>&& in_opt_contextAttributes)
2999 {
3000 JSON::ObjectBase::setObject("contextAttributes"_s, WTFMove(in_opt_contextAttributes));
3001 }
3002
3003 void setMemoryCost(double in_opt_memoryCost)
3004 {
3005 JSON::ObjectBase::setDouble("memoryCost"_s, in_opt_memoryCost);
3006 }
3007
3008 void setBacktrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_backtrace)
3009 {
3010 JSON::ObjectBase::setArray("backtrace"_s, WTFMove(in_opt_backtrace));
3011 }
3012};
3013
3014#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
3015/* Information about a WebGL/WebGL2 shader program or WebGPU shader pipeline. */
3016class ShaderProgram final : public JSON::ObjectBase {
3017public:
3018 enum {
3019 NoFieldsSet = 0,
3020 ProgramIdSet = 1 << 0,
3021 ProgramTypeSet = 1 << 1,
3022 CanvasIdSet = 1 << 2,
3023 AllFieldsSet = (ProgramIdSet | ProgramTypeSet | CanvasIdSet)
3024 };
3025
3026 template<int STATE>
3027 class Builder {
3028 private:
3029 RefPtr<JSON::Object> m_result;
3030
3031 template<int STEP> Builder<STATE | STEP>& castState()
3032 {
3033 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3034 }
3035
3036 Builder(Ref</*ShaderProgram*/JSON::Object>&& object)
3037 : m_result(WTFMove(object))
3038 {
3039 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3040 }
3041 friend class ShaderProgram;
3042 public:
3043
3044 Builder<STATE | ProgramIdSet>& setProgramId(const String& in_programId)
3045 {
3046 COMPILE_ASSERT(!(STATE & ProgramIdSet), property_programId_already_set);
3047 m_result->setString("programId"_s, in_programId);
3048 return castState<ProgramIdSet>();
3049 }
3050
3051 Builder<STATE | ProgramTypeSet>& setProgramType(Protocol::Canvas::ProgramType in_programType)
3052 {
3053 COMPILE_ASSERT(!(STATE & ProgramTypeSet), property_programType_already_set);
3054 m_result->setString("programType"_s, Protocol::Helpers::getEnumConstantValue(in_programType));
3055 return castState<ProgramTypeSet>();
3056 }
3057
3058 Builder<STATE | CanvasIdSet>& setCanvasId(const String& in_canvasId)
3059 {
3060 COMPILE_ASSERT(!(STATE & CanvasIdSet), property_canvasId_already_set);
3061 m_result->setString("canvasId"_s, in_canvasId);
3062 return castState<CanvasIdSet>();
3063 }
3064
3065 Ref<ShaderProgram> release()
3066 {
3067 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3068 COMPILE_ASSERT(sizeof(ShaderProgram) == sizeof(JSON::Object), cannot_cast);
3069
3070 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3071 auto result = WTFMove(*reinterpret_cast<Ref<ShaderProgram>*>(&jsonResult));
3072 return result;
3073 }
3074 };
3075
3076 /*
3077 * Synthetic constructor:
3078 * Ref<ShaderProgram> result = ShaderProgram::create()
3079 * .setProgramId(...)
3080 * .setProgramType(...)
3081 * .setCanvasId(...)
3082 * .release();
3083 */
3084 static Builder<NoFieldsSet> create()
3085 {
3086 return Builder<NoFieldsSet>(JSON::Object::create());
3087 }
3088
3089 void setSharesVertexFragmentShader(bool in_opt_sharesVertexFragmentShader)
3090 {
3091 JSON::ObjectBase::setBoolean("sharesVertexFragmentShader"_s, in_opt_sharesVertexFragmentShader);
3092 }
3093};
3094#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
3095
3096} // Canvas
3097
3098namespace Console {
3099
3100/* Channels for different types of log messages. */
3101enum class ChannelSource {
3102 XML = 54,
3103 JavaScript = 55,
3104 Network = 56,
3105 ConsoleAPI = 57,
3106 Storage = 58,
3107 Appcache = 59,
3108 Rendering = 60,
3109 CSS = 61,
3110 Security = 62,
3111 ContentBlocker = 63,
3112 Media = 64,
3113 MediaSource = 65,
3114 WebRTC = 66,
3115 ITPDebug = 67,
3116 PrivateClickMeasurement = 68,
3117 PaymentRequest = 69,
3118 Other = 70,
3119}; // enum class ChannelSource
3120
3121/* Level of logging. */
3122enum class ChannelLevel {
3123 Off = 71,
3124 Basic = 72,
3125 Verbose = 73,
3126}; // enum class ChannelLevel
3127
3128/* Logging channel. */
3129class Channel final : public JSON::ObjectBase {
3130public:
3131 enum {
3132 NoFieldsSet = 0,
3133 SourceSet = 1 << 0,
3134 LevelSet = 1 << 1,
3135 AllFieldsSet = (SourceSet | LevelSet)
3136 };
3137
3138 template<int STATE>
3139 class Builder {
3140 private:
3141 RefPtr<JSON::Object> m_result;
3142
3143 template<int STEP> Builder<STATE | STEP>& castState()
3144 {
3145 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3146 }
3147
3148 Builder(Ref</*Channel*/JSON::Object>&& object)
3149 : m_result(WTFMove(object))
3150 {
3151 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3152 }
3153 friend class Channel;
3154 public:
3155
3156 Builder<STATE | SourceSet>& setSource(Protocol::Console::ChannelSource in_source)
3157 {
3158 COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
3159 m_result->setString("source"_s, Protocol::Helpers::getEnumConstantValue(in_source));
3160 return castState<SourceSet>();
3161 }
3162
3163 Builder<STATE | LevelSet>& setLevel(Protocol::Console::ChannelLevel in_level)
3164 {
3165 COMPILE_ASSERT(!(STATE & LevelSet), property_level_already_set);
3166 m_result->setString("level"_s, Protocol::Helpers::getEnumConstantValue(in_level));
3167 return castState<LevelSet>();
3168 }
3169
3170 Ref<Channel> release()
3171 {
3172 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3173 COMPILE_ASSERT(sizeof(Channel) == sizeof(JSON::Object), cannot_cast);
3174
3175 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3176 auto result = WTFMove(*reinterpret_cast<Ref<Channel>*>(&jsonResult));
3177 return result;
3178 }
3179 };
3180
3181 /*
3182 * Synthetic constructor:
3183 * Ref<Channel> result = Channel::create()
3184 * .setSource(...)
3185 * .setLevel(...)
3186 * .release();
3187 */
3188 static Builder<NoFieldsSet> create()
3189 {
3190 return Builder<NoFieldsSet>(JSON::Object::create());
3191 }
3192};
3193
3194/* Console message. */
3195class ConsoleMessage final : public JSON::ObjectBase {
3196public:
3197 // Named after property name 'level' while generating ConsoleMessage.
3198 enum class Level {
3199 Log = 74,
3200 Info = 75,
3201 Warning = 76,
3202 Error = 77,
3203 Debug = 78,
3204 }; // enum class Level
3205
3206 // Named after property name 'type' while generating ConsoleMessage.
3207 enum class Type {
3208 Log = 74,
3209 Dir = 79,
3210 DirXML = 80,
3211 Table = 81,
3212 Trace = 82,
3213 Clear = 83,
3214 StartGroup = 84,
3215 StartGroupCollapsed = 85,
3216 EndGroup = 86,
3217 Assert = 87,
3218 Timing = 88,
3219 Profile = 89,
3220 ProfileEnd = 90,
3221 Image = 91,
3222 }; // enum class Type
3223
3224 enum {
3225 NoFieldsSet = 0,
3226 SourceSet = 1 << 0,
3227 LevelSet = 1 << 1,
3228 TextSet = 1 << 2,
3229 AllFieldsSet = (SourceSet | LevelSet | TextSet)
3230 };
3231
3232 template<int STATE>
3233 class Builder {
3234 private:
3235 RefPtr<JSON::Object> m_result;
3236
3237 template<int STEP> Builder<STATE | STEP>& castState()
3238 {
3239 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3240 }
3241
3242 Builder(Ref</*ConsoleMessage*/JSON::Object>&& object)
3243 : m_result(WTFMove(object))
3244 {
3245 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3246 }
3247 friend class ConsoleMessage;
3248 public:
3249
3250 Builder<STATE | SourceSet>& setSource(Protocol::Console::ChannelSource in_source)
3251 {
3252 COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
3253 m_result->setString("source"_s, Protocol::Helpers::getEnumConstantValue(in_source));
3254 return castState<SourceSet>();
3255 }
3256
3257 Builder<STATE | LevelSet>& setLevel(Level in_level)
3258 {
3259 COMPILE_ASSERT(!(STATE & LevelSet), property_level_already_set);
3260 m_result->setString("level"_s, Protocol::Helpers::getEnumConstantValue(in_level));
3261 return castState<LevelSet>();
3262 }
3263
3264 Builder<STATE | TextSet>& setText(const String& in_text)
3265 {
3266 COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
3267 m_result->setString("text"_s, in_text);
3268 return castState<TextSet>();
3269 }
3270
3271 Ref<ConsoleMessage> release()
3272 {
3273 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3274 COMPILE_ASSERT(sizeof(ConsoleMessage) == sizeof(JSON::Object), cannot_cast);
3275
3276 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3277 auto result = WTFMove(*reinterpret_cast<Ref<ConsoleMessage>*>(&jsonResult));
3278 return result;
3279 }
3280 };
3281
3282 /*
3283 * Synthetic constructor:
3284 * Ref<ConsoleMessage> result = ConsoleMessage::create()
3285 * .setSource(...)
3286 * .setLevel(...)
3287 * .setText(...)
3288 * .release();
3289 */
3290 static Builder<NoFieldsSet> create()
3291 {
3292 return Builder<NoFieldsSet>(JSON::Object::create());
3293 }
3294
3295 void setType(Type in_opt_type)
3296 {
3297 JSON::ObjectBase::setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_opt_type));
3298 }
3299
3300 void setUrl(const String& in_opt_url)
3301 {
3302 JSON::ObjectBase::setString("url"_s, in_opt_url);
3303 }
3304
3305 void setLine(int in_opt_line)
3306 {
3307 JSON::ObjectBase::setInteger("line"_s, in_opt_line);
3308 }
3309
3310 void setColumn(int in_opt_column)
3311 {
3312 JSON::ObjectBase::setInteger("column"_s, in_opt_column);
3313 }
3314
3315 void setRepeatCount(int in_opt_repeatCount)
3316 {
3317 JSON::ObjectBase::setInteger("repeatCount"_s, in_opt_repeatCount);
3318 }
3319
3320 void setParameters(Ref<JSON::ArrayOf<Protocol::Runtime::RemoteObject>>&& in_opt_parameters)
3321 {
3322 JSON::ObjectBase::setArray("parameters"_s, WTFMove(in_opt_parameters));
3323 }
3324
3325 void setStackTrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_stackTrace)
3326 {
3327 JSON::ObjectBase::setArray("stackTrace"_s, WTFMove(in_opt_stackTrace));
3328 }
3329
3330 void setNetworkRequestId(const String& in_opt_networkRequestId)
3331 {
3332 JSON::ObjectBase::setString("networkRequestId"_s, in_opt_networkRequestId);
3333 }
3334};
3335
3336/* Stack entry for console errors and assertions. */
3337class CallFrame final : public JSON::ObjectBase {
3338public:
3339 enum {
3340 NoFieldsSet = 0,
3341 FunctionNameSet = 1 << 0,
3342 UrlSet = 1 << 1,
3343 ScriptIdSet = 1 << 2,
3344 LineNumberSet = 1 << 3,
3345 ColumnNumberSet = 1 << 4,
3346 AllFieldsSet = (FunctionNameSet | UrlSet | ScriptIdSet | LineNumberSet | ColumnNumberSet)
3347 };
3348
3349 template<int STATE>
3350 class Builder {
3351 private:
3352 RefPtr<JSON::Object> m_result;
3353
3354 template<int STEP> Builder<STATE | STEP>& castState()
3355 {
3356 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3357 }
3358
3359 Builder(Ref</*CallFrame*/JSON::Object>&& object)
3360 : m_result(WTFMove(object))
3361 {
3362 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3363 }
3364 friend class CallFrame;
3365 public:
3366
3367 Builder<STATE | FunctionNameSet>& setFunctionName(const String& in_functionName)
3368 {
3369 COMPILE_ASSERT(!(STATE & FunctionNameSet), property_functionName_already_set);
3370 m_result->setString("functionName"_s, in_functionName);
3371 return castState<FunctionNameSet>();
3372 }
3373
3374 Builder<STATE | UrlSet>& setUrl(const String& in_url)
3375 {
3376 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
3377 m_result->setString("url"_s, in_url);
3378 return castState<UrlSet>();
3379 }
3380
3381 Builder<STATE | ScriptIdSet>& setScriptId(const String& in_scriptId)
3382 {
3383 COMPILE_ASSERT(!(STATE & ScriptIdSet), property_scriptId_already_set);
3384 m_result->setString("scriptId"_s, in_scriptId);
3385 return castState<ScriptIdSet>();
3386 }
3387
3388 Builder<STATE | LineNumberSet>& setLineNumber(int in_lineNumber)
3389 {
3390 COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
3391 m_result->setInteger("lineNumber"_s, in_lineNumber);
3392 return castState<LineNumberSet>();
3393 }
3394
3395 Builder<STATE | ColumnNumberSet>& setColumnNumber(int in_columnNumber)
3396 {
3397 COMPILE_ASSERT(!(STATE & ColumnNumberSet), property_columnNumber_already_set);
3398 m_result->setInteger("columnNumber"_s, in_columnNumber);
3399 return castState<ColumnNumberSet>();
3400 }
3401
3402 Ref<CallFrame> release()
3403 {
3404 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3405 COMPILE_ASSERT(sizeof(CallFrame) == sizeof(JSON::Object), cannot_cast);
3406
3407 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3408 auto result = WTFMove(*reinterpret_cast<Ref<CallFrame>*>(&jsonResult));
3409 return result;
3410 }
3411 };
3412
3413 /*
3414 * Synthetic constructor:
3415 * Ref<CallFrame> result = CallFrame::create()
3416 * .setFunctionName(...)
3417 * .setUrl(...)
3418 * .setScriptId(...)
3419 * .setLineNumber(...)
3420 * .setColumnNumber(...)
3421 * .release();
3422 */
3423 static Builder<NoFieldsSet> create()
3424 {
3425 return Builder<NoFieldsSet>(JSON::Object::create());
3426 }
3427};
3428
3429/* Call frames for async function calls, console assertions, and error messages. */
3430class StackTrace final : public JSON::ObjectBase {
3431public:
3432 enum {
3433 NoFieldsSet = 0,
3434 CallFramesSet = 1 << 0,
3435 AllFieldsSet = (CallFramesSet)
3436 };
3437
3438 template<int STATE>
3439 class Builder {
3440 private:
3441 RefPtr<JSON::Object> m_result;
3442
3443 template<int STEP> Builder<STATE | STEP>& castState()
3444 {
3445 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3446 }
3447
3448 Builder(Ref</*StackTrace*/JSON::Object>&& object)
3449 : m_result(WTFMove(object))
3450 {
3451 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3452 }
3453 friend class StackTrace;
3454 public:
3455
3456 Builder<STATE | CallFramesSet>& setCallFrames(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_callFrames)
3457 {
3458 COMPILE_ASSERT(!(STATE & CallFramesSet), property_callFrames_already_set);
3459 m_result->setArray("callFrames"_s, WTFMove(in_callFrames));
3460 return castState<CallFramesSet>();
3461 }
3462
3463 Ref<StackTrace> release()
3464 {
3465 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3466 COMPILE_ASSERT(sizeof(StackTrace) == sizeof(JSON::Object), cannot_cast);
3467
3468 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3469 auto result = WTFMove(*reinterpret_cast<Ref<StackTrace>*>(&jsonResult));
3470 return result;
3471 }
3472 };
3473
3474 /*
3475 * Synthetic constructor:
3476 * Ref<StackTrace> result = StackTrace::create()
3477 * .setCallFrames(...)
3478 * .release();
3479 */
3480 static Builder<NoFieldsSet> create()
3481 {
3482 return Builder<NoFieldsSet>(JSON::Object::create());
3483 }
3484
3485 void setTopCallFrameIsBoundary(bool in_opt_topCallFrameIsBoundary)
3486 {
3487 JSON::ObjectBase::setBoolean("topCallFrameIsBoundary"_s, in_opt_topCallFrameIsBoundary);
3488 }
3489
3490 void setTruncated(bool in_opt_truncated)
3491 {
3492 JSON::ObjectBase::setBoolean("truncated"_s, in_opt_truncated);
3493 }
3494
3495 void setParentStackTrace(Ref<Protocol::Console::StackTrace>&& in_opt_parentStackTrace)
3496 {
3497 JSON::ObjectBase::setObject("parentStackTrace"_s, WTFMove(in_opt_parentStackTrace));
3498 }
3499};
3500
3501} // Console
3502
3503namespace DOM {
3504
3505/* Pseudo element type. */
3506enum class PseudoType {
3507 Before = 24,
3508 After = 25,
3509}; // enum class PseudoType
3510
3511/* Shadow root type. */
3512enum class ShadowRootType {
3513 UserAgent = 17,
3514 Open = 92,
3515 Closed = 93,
3516}; // enum class ShadowRootType
3517
3518/* Custom element state. */
3519enum class CustomElementState {
3520 Builtin = 94,
3521 Custom = 95,
3522 Waiting = 96,
3523 Failed = 97,
3524}; // enum class CustomElementState
3525
3526/* Token values of @aria-relevant attribute. */
3527enum class LiveRegionRelevant {
3528 Additions = 98,
3529 Removals = 99,
3530 Text = 100,
3531}; // enum class LiveRegionRelevant
3532
3533/* DOM interaction is implemented in terms of mirror objects that represent the actual DOM nodes. DOMNode is a base node mirror type. */
3534class Node final : public JSON::ObjectBase {
3535public:
3536 enum {
3537 NoFieldsSet = 0,
3538 NodeIdSet = 1 << 0,
3539 NodeTypeSet = 1 << 1,
3540 NodeNameSet = 1 << 2,
3541 LocalNameSet = 1 << 3,
3542 NodeValueSet = 1 << 4,
3543 AllFieldsSet = (NodeIdSet | NodeTypeSet | NodeNameSet | LocalNameSet | NodeValueSet)
3544 };
3545
3546 template<int STATE>
3547 class Builder {
3548 private:
3549 RefPtr<JSON::Object> m_result;
3550
3551 template<int STEP> Builder<STATE | STEP>& castState()
3552 {
3553 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3554 }
3555
3556 Builder(Ref</*Node*/JSON::Object>&& object)
3557 : m_result(WTFMove(object))
3558 {
3559 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3560 }
3561 friend class Node;
3562 public:
3563
3564 Builder<STATE | NodeIdSet>& setNodeId(int in_nodeId)
3565 {
3566 COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
3567 m_result->setInteger("nodeId"_s, in_nodeId);
3568 return castState<NodeIdSet>();
3569 }
3570
3571 Builder<STATE | NodeTypeSet>& setNodeType(int in_nodeType)
3572 {
3573 COMPILE_ASSERT(!(STATE & NodeTypeSet), property_nodeType_already_set);
3574 m_result->setInteger("nodeType"_s, in_nodeType);
3575 return castState<NodeTypeSet>();
3576 }
3577
3578 Builder<STATE | NodeNameSet>& setNodeName(const String& in_nodeName)
3579 {
3580 COMPILE_ASSERT(!(STATE & NodeNameSet), property_nodeName_already_set);
3581 m_result->setString("nodeName"_s, in_nodeName);
3582 return castState<NodeNameSet>();
3583 }
3584
3585 Builder<STATE | LocalNameSet>& setLocalName(const String& in_localName)
3586 {
3587 COMPILE_ASSERT(!(STATE & LocalNameSet), property_localName_already_set);
3588 m_result->setString("localName"_s, in_localName);
3589 return castState<LocalNameSet>();
3590 }
3591
3592 Builder<STATE | NodeValueSet>& setNodeValue(const String& in_nodeValue)
3593 {
3594 COMPILE_ASSERT(!(STATE & NodeValueSet), property_nodeValue_already_set);
3595 m_result->setString("nodeValue"_s, in_nodeValue);
3596 return castState<NodeValueSet>();
3597 }
3598
3599 Ref<Node> release()
3600 {
3601 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3602 COMPILE_ASSERT(sizeof(Node) == sizeof(JSON::Object), cannot_cast);
3603
3604 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3605 auto result = WTFMove(*reinterpret_cast<Ref<Node>*>(&jsonResult));
3606 return result;
3607 }
3608 };
3609
3610 /*
3611 * Synthetic constructor:
3612 * Ref<Node> result = Node::create()
3613 * .setNodeId(...)
3614 * .setNodeType(...)
3615 * .setNodeName(...)
3616 * .setLocalName(...)
3617 * .setNodeValue(...)
3618 * .release();
3619 */
3620 static Builder<NoFieldsSet> create()
3621 {
3622 return Builder<NoFieldsSet>(JSON::Object::create());
3623 }
3624
3625 void setFrameId(const String& in_opt_frameId)
3626 {
3627 JSON::ObjectBase::setString("frameId"_s, in_opt_frameId);
3628 }
3629
3630 void setChildNodeCount(int in_opt_childNodeCount)
3631 {
3632 JSON::ObjectBase::setInteger("childNodeCount"_s, in_opt_childNodeCount);
3633 }
3634
3635 void setChildren(Ref<JSON::ArrayOf<Protocol::DOM::Node>>&& in_opt_children)
3636 {
3637 JSON::ObjectBase::setArray("children"_s, WTFMove(in_opt_children));
3638 }
3639
3640 void setAttributes(Ref<JSON::ArrayOf<String>>&& in_opt_attributes)
3641 {
3642 JSON::ObjectBase::setArray("attributes"_s, WTFMove(in_opt_attributes));
3643 }
3644
3645 void setDocumentURL(const String& in_opt_documentURL)
3646 {
3647 JSON::ObjectBase::setString("documentURL"_s, in_opt_documentURL);
3648 }
3649
3650 void setBaseURL(const String& in_opt_baseURL)
3651 {
3652 JSON::ObjectBase::setString("baseURL"_s, in_opt_baseURL);
3653 }
3654
3655 void setPublicId(const String& in_opt_publicId)
3656 {
3657 JSON::ObjectBase::setString("publicId"_s, in_opt_publicId);
3658 }
3659
3660 void setSystemId(const String& in_opt_systemId)
3661 {
3662 JSON::ObjectBase::setString("systemId"_s, in_opt_systemId);
3663 }
3664
3665 void setXmlVersion(const String& in_opt_xmlVersion)
3666 {
3667 JSON::ObjectBase::setString("xmlVersion"_s, in_opt_xmlVersion);
3668 }
3669
3670 void setName(const String& in_opt_name)
3671 {
3672 JSON::ObjectBase::setString("name"_s, in_opt_name);
3673 }
3674
3675 void setValue(const String& in_opt_value)
3676 {
3677 JSON::ObjectBase::setString("value"_s, in_opt_value);
3678 }
3679
3680 void setPseudoType(Protocol::DOM::PseudoType in_opt_pseudoType)
3681 {
3682 JSON::ObjectBase::setString("pseudoType"_s, Protocol::Helpers::getEnumConstantValue(in_opt_pseudoType));
3683 }
3684
3685 void setShadowRootType(Protocol::DOM::ShadowRootType in_opt_shadowRootType)
3686 {
3687 JSON::ObjectBase::setString("shadowRootType"_s, Protocol::Helpers::getEnumConstantValue(in_opt_shadowRootType));
3688 }
3689
3690 void setCustomElementState(Protocol::DOM::CustomElementState in_opt_customElementState)
3691 {
3692 JSON::ObjectBase::setString("customElementState"_s, Protocol::Helpers::getEnumConstantValue(in_opt_customElementState));
3693 }
3694
3695 void setContentDocument(Ref<Protocol::DOM::Node>&& in_opt_contentDocument)
3696 {
3697 JSON::ObjectBase::setObject("contentDocument"_s, WTFMove(in_opt_contentDocument));
3698 }
3699
3700 void setShadowRoots(Ref<JSON::ArrayOf<Protocol::DOM::Node>>&& in_opt_shadowRoots)
3701 {
3702 JSON::ObjectBase::setArray("shadowRoots"_s, WTFMove(in_opt_shadowRoots));
3703 }
3704
3705 void setTemplateContent(Ref<Protocol::DOM::Node>&& in_opt_templateContent)
3706 {
3707 JSON::ObjectBase::setObject("templateContent"_s, WTFMove(in_opt_templateContent));
3708 }
3709
3710 void setPseudoElements(Ref<JSON::ArrayOf<Protocol::DOM::Node>>&& in_opt_pseudoElements)
3711 {
3712 JSON::ObjectBase::setArray("pseudoElements"_s, WTFMove(in_opt_pseudoElements));
3713 }
3714
3715 void setContentSecurityPolicyHash(const String& in_opt_contentSecurityPolicyHash)
3716 {
3717 JSON::ObjectBase::setString("contentSecurityPolicyHash"_s, in_opt_contentSecurityPolicyHash);
3718 }
3719
3720 void setLayoutContextType(Protocol::CSS::LayoutContextType in_opt_layoutContextType)
3721 {
3722 JSON::ObjectBase::setString("layoutContextType"_s, Protocol::Helpers::getEnumConstantValue(in_opt_layoutContextType));
3723 }
3724};
3725
3726/* Relationship between data that is associated with a node and the node itself. */
3727class DataBinding final : public JSON::ObjectBase {
3728public:
3729 enum {
3730 NoFieldsSet = 0,
3731 BindingSet = 1 << 0,
3732 ValueSet = 1 << 1,
3733 AllFieldsSet = (BindingSet | ValueSet)
3734 };
3735
3736 template<int STATE>
3737 class Builder {
3738 private:
3739 RefPtr<JSON::Object> m_result;
3740
3741 template<int STEP> Builder<STATE | STEP>& castState()
3742 {
3743 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3744 }
3745
3746 Builder(Ref</*DataBinding*/JSON::Object>&& object)
3747 : m_result(WTFMove(object))
3748 {
3749 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3750 }
3751 friend class DataBinding;
3752 public:
3753
3754 Builder<STATE | BindingSet>& setBinding(const String& in_binding)
3755 {
3756 COMPILE_ASSERT(!(STATE & BindingSet), property_binding_already_set);
3757 m_result->setString("binding"_s, in_binding);
3758 return castState<BindingSet>();
3759 }
3760
3761 Builder<STATE | ValueSet>& setValue(const String& in_value)
3762 {
3763 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
3764 m_result->setString("value"_s, in_value);
3765 return castState<ValueSet>();
3766 }
3767
3768 Ref<DataBinding> release()
3769 {
3770 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3771 COMPILE_ASSERT(sizeof(DataBinding) == sizeof(JSON::Object), cannot_cast);
3772
3773 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3774 auto result = WTFMove(*reinterpret_cast<Ref<DataBinding>*>(&jsonResult));
3775 return result;
3776 }
3777 };
3778
3779 /*
3780 * Synthetic constructor:
3781 * Ref<DataBinding> result = DataBinding::create()
3782 * .setBinding(...)
3783 * .setValue(...)
3784 * .release();
3785 */
3786 static Builder<NoFieldsSet> create()
3787 {
3788 return Builder<NoFieldsSet>(JSON::Object::create());
3789 }
3790
3791 void setType(const String& in_opt_type)
3792 {
3793 JSON::ObjectBase::setString("type"_s, in_opt_type);
3794 }
3795};
3796
3797/* A structure holding event listener properties. */
3798class EventListener final : public JSON::ObjectBase {
3799public:
3800 enum {
3801 NoFieldsSet = 0,
3802 EventListenerIdSet = 1 << 0,
3803 TypeSet = 1 << 1,
3804 UseCaptureSet = 1 << 2,
3805 IsAttributeSet = 1 << 3,
3806 AllFieldsSet = (EventListenerIdSet | TypeSet | UseCaptureSet | IsAttributeSet)
3807 };
3808
3809 template<int STATE>
3810 class Builder {
3811 private:
3812 RefPtr<JSON::Object> m_result;
3813
3814 template<int STEP> Builder<STATE | STEP>& castState()
3815 {
3816 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3817 }
3818
3819 Builder(Ref</*EventListener*/JSON::Object>&& object)
3820 : m_result(WTFMove(object))
3821 {
3822 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3823 }
3824 friend class EventListener;
3825 public:
3826
3827 Builder<STATE | EventListenerIdSet>& setEventListenerId(int in_eventListenerId)
3828 {
3829 COMPILE_ASSERT(!(STATE & EventListenerIdSet), property_eventListenerId_already_set);
3830 m_result->setInteger("eventListenerId"_s, in_eventListenerId);
3831 return castState<EventListenerIdSet>();
3832 }
3833
3834 Builder<STATE | TypeSet>& setType(const String& in_type)
3835 {
3836 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
3837 m_result->setString("type"_s, in_type);
3838 return castState<TypeSet>();
3839 }
3840
3841 Builder<STATE | UseCaptureSet>& setUseCapture(bool in_useCapture)
3842 {
3843 COMPILE_ASSERT(!(STATE & UseCaptureSet), property_useCapture_already_set);
3844 m_result->setBoolean("useCapture"_s, in_useCapture);
3845 return castState<UseCaptureSet>();
3846 }
3847
3848 Builder<STATE | IsAttributeSet>& setIsAttribute(bool in_isAttribute)
3849 {
3850 COMPILE_ASSERT(!(STATE & IsAttributeSet), property_isAttribute_already_set);
3851 m_result->setBoolean("isAttribute"_s, in_isAttribute);
3852 return castState<IsAttributeSet>();
3853 }
3854
3855 Ref<EventListener> release()
3856 {
3857 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3858 COMPILE_ASSERT(sizeof(EventListener) == sizeof(JSON::Object), cannot_cast);
3859
3860 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3861 auto result = WTFMove(*reinterpret_cast<Ref<EventListener>*>(&jsonResult));
3862 return result;
3863 }
3864 };
3865
3866 /*
3867 * Synthetic constructor:
3868 * Ref<EventListener> result = EventListener::create()
3869 * .setEventListenerId(...)
3870 * .setType(...)
3871 * .setUseCapture(...)
3872 * .setIsAttribute(...)
3873 * .release();
3874 */
3875 static Builder<NoFieldsSet> create()
3876 {
3877 return Builder<NoFieldsSet>(JSON::Object::create());
3878 }
3879
3880 void setNodeId(int in_opt_nodeId)
3881 {
3882 JSON::ObjectBase::setInteger("nodeId"_s, in_opt_nodeId);
3883 }
3884
3885 void setOnWindow(bool in_opt_onWindow)
3886 {
3887 JSON::ObjectBase::setBoolean("onWindow"_s, in_opt_onWindow);
3888 }
3889
3890 void setLocation(Ref<Protocol::Debugger::Location>&& in_opt_location)
3891 {
3892 JSON::ObjectBase::setObject("location"_s, WTFMove(in_opt_location));
3893 }
3894
3895 void setHandlerName(const String& in_opt_handlerName)
3896 {
3897 JSON::ObjectBase::setString("handlerName"_s, in_opt_handlerName);
3898 }
3899
3900 void setPassive(bool in_opt_passive)
3901 {
3902 JSON::ObjectBase::setBoolean("passive"_s, in_opt_passive);
3903 }
3904
3905 void setOnce(bool in_opt_once)
3906 {
3907 JSON::ObjectBase::setBoolean("once"_s, in_opt_once);
3908 }
3909
3910 void setDisabled(bool in_opt_disabled)
3911 {
3912 JSON::ObjectBase::setBoolean("disabled"_s, in_opt_disabled);
3913 }
3914
3915 void setHasBreakpoint(bool in_opt_hasBreakpoint)
3916 {
3917 JSON::ObjectBase::setBoolean("hasBreakpoint"_s, in_opt_hasBreakpoint);
3918 }
3919};
3920
3921/* A structure holding accessibility properties. */
3922class AccessibilityProperties final : public JSON::ObjectBase {
3923public:
3924 // Named after property name 'checked' while generating AccessibilityProperties.
3925 enum class Checked {
3926 True = 101,
3927 False = 102,
3928 Mixed = 103,
3929 }; // enum class Checked
3930
3931 // Named after property name 'current' while generating AccessibilityProperties.
3932 enum class Current {
3933 True = 101,
3934 False = 102,
3935 Page = 104,
3936 Step = 105,
3937 Location = 106,
3938 Date = 107,
3939 Time = 108,
3940 }; // enum class Current
3941
3942 // Named after property name 'invalid' while generating AccessibilityProperties.
3943 enum class Invalid {
3944 True = 101,
3945 False = 102,
3946 Grammar = 109,
3947 Spelling = 110,
3948 }; // enum class Invalid
3949
3950 // Named after property name 'liveRegionStatus' while generating AccessibilityProperties.
3951 enum class LiveRegionStatus {
3952 Assertive = 111,
3953 Polite = 112,
3954 Off = 71,
3955 }; // enum class LiveRegionStatus
3956
3957 enum {
3958 NoFieldsSet = 0,
3959 ExistsSet = 1 << 0,
3960 LabelSet = 1 << 1,
3961 NodeIdSet = 1 << 2,
3962 RoleSet = 1 << 3,
3963 AllFieldsSet = (ExistsSet | LabelSet | NodeIdSet | RoleSet)
3964 };
3965
3966 template<int STATE>
3967 class Builder {
3968 private:
3969 RefPtr<JSON::Object> m_result;
3970
3971 template<int STEP> Builder<STATE | STEP>& castState()
3972 {
3973 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3974 }
3975
3976 Builder(Ref</*AccessibilityProperties*/JSON::Object>&& object)
3977 : m_result(WTFMove(object))
3978 {
3979 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3980 }
3981 friend class AccessibilityProperties;
3982 public:
3983
3984 Builder<STATE | ExistsSet>& setExists(bool in_exists)
3985 {
3986 COMPILE_ASSERT(!(STATE & ExistsSet), property_exists_already_set);
3987 m_result->setBoolean("exists"_s, in_exists);
3988 return castState<ExistsSet>();
3989 }
3990
3991 Builder<STATE | LabelSet>& setLabel(const String& in_label)
3992 {
3993 COMPILE_ASSERT(!(STATE & LabelSet), property_label_already_set);
3994 m_result->setString("label"_s, in_label);
3995 return castState<LabelSet>();
3996 }
3997
3998 Builder<STATE | NodeIdSet>& setNodeId(int in_nodeId)
3999 {
4000 COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
4001 m_result->setInteger("nodeId"_s, in_nodeId);
4002 return castState<NodeIdSet>();
4003 }
4004
4005 Builder<STATE | RoleSet>& setRole(const String& in_role)
4006 {
4007 COMPILE_ASSERT(!(STATE & RoleSet), property_role_already_set);
4008 m_result->setString("role"_s, in_role);
4009 return castState<RoleSet>();
4010 }
4011
4012 Ref<AccessibilityProperties> release()
4013 {
4014 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4015 COMPILE_ASSERT(sizeof(AccessibilityProperties) == sizeof(JSON::Object), cannot_cast);
4016
4017 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4018 auto result = WTFMove(*reinterpret_cast<Ref<AccessibilityProperties>*>(&jsonResult));
4019 return result;
4020 }
4021 };
4022
4023 /*
4024 * Synthetic constructor:
4025 * Ref<AccessibilityProperties> result = AccessibilityProperties::create()
4026 * .setExists(...)
4027 * .setLabel(...)
4028 * .setNodeId(...)
4029 * .setRole(...)
4030 * .release();
4031 */
4032 static Builder<NoFieldsSet> create()
4033 {
4034 return Builder<NoFieldsSet>(JSON::Object::create());
4035 }
4036
4037 void setActiveDescendantNodeId(int in_opt_activeDescendantNodeId)
4038 {
4039 JSON::ObjectBase::setInteger("activeDescendantNodeId"_s, in_opt_activeDescendantNodeId);
4040 }
4041
4042 void setBusy(bool in_opt_busy)
4043 {
4044 JSON::ObjectBase::setBoolean("busy"_s, in_opt_busy);
4045 }
4046
4047 void setChecked(Checked in_opt_checked)
4048 {
4049 JSON::ObjectBase::setString("checked"_s, Protocol::Helpers::getEnumConstantValue(in_opt_checked));
4050 }
4051
4052 void setChildNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_childNodeIds)
4053 {
4054 JSON::ObjectBase::setArray("childNodeIds"_s, WTFMove(in_opt_childNodeIds));
4055 }
4056
4057 void setControlledNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_controlledNodeIds)
4058 {
4059 JSON::ObjectBase::setArray("controlledNodeIds"_s, WTFMove(in_opt_controlledNodeIds));
4060 }
4061
4062 void setCurrent(Current in_opt_current)
4063 {
4064 JSON::ObjectBase::setString("current"_s, Protocol::Helpers::getEnumConstantValue(in_opt_current));
4065 }
4066
4067 void setDisabled(bool in_opt_disabled)
4068 {
4069 JSON::ObjectBase::setBoolean("disabled"_s, in_opt_disabled);
4070 }
4071
4072 void setHeadingLevel(double in_opt_headingLevel)
4073 {
4074 JSON::ObjectBase::setDouble("headingLevel"_s, in_opt_headingLevel);
4075 }
4076
4077 void setHierarchyLevel(double in_opt_hierarchyLevel)
4078 {
4079 JSON::ObjectBase::setDouble("hierarchyLevel"_s, in_opt_hierarchyLevel);
4080 }
4081
4082 void setIsPopUpButton(bool in_opt_isPopUpButton)
4083 {
4084 JSON::ObjectBase::setBoolean("isPopUpButton"_s, in_opt_isPopUpButton);
4085 }
4086
4087 void setExpanded(bool in_opt_expanded)
4088 {
4089 JSON::ObjectBase::setBoolean("expanded"_s, in_opt_expanded);
4090 }
4091
4092 void setFlowedNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_flowedNodeIds)
4093 {
4094 JSON::ObjectBase::setArray("flowedNodeIds"_s, WTFMove(in_opt_flowedNodeIds));
4095 }
4096
4097 void setFocused(bool in_opt_focused)
4098 {
4099 JSON::ObjectBase::setBoolean("focused"_s, in_opt_focused);
4100 }
4101
4102 void setIgnored(bool in_opt_ignored)
4103 {
4104 JSON::ObjectBase::setBoolean("ignored"_s, in_opt_ignored);
4105 }
4106
4107 void setIgnoredByDefault(bool in_opt_ignoredByDefault)
4108 {
4109 JSON::ObjectBase::setBoolean("ignoredByDefault"_s, in_opt_ignoredByDefault);
4110 }
4111
4112 void setInvalid(Invalid in_opt_invalid)
4113 {
4114 JSON::ObjectBase::setString("invalid"_s, Protocol::Helpers::getEnumConstantValue(in_opt_invalid));
4115 }
4116
4117 void setHidden(bool in_opt_hidden)
4118 {
4119 JSON::ObjectBase::setBoolean("hidden"_s, in_opt_hidden);
4120 }
4121
4122 void setLiveRegionAtomic(bool in_opt_liveRegionAtomic)
4123 {
4124 JSON::ObjectBase::setBoolean("liveRegionAtomic"_s, in_opt_liveRegionAtomic);
4125 }
4126
4127 void setLiveRegionRelevant(Ref<JSON::ArrayOf<String>>&& in_opt_liveRegionRelevant)
4128 {
4129 JSON::ObjectBase::setArray("liveRegionRelevant"_s, WTFMove(in_opt_liveRegionRelevant));
4130 }
4131
4132 void setLiveRegionStatus(LiveRegionStatus in_opt_liveRegionStatus)
4133 {
4134 JSON::ObjectBase::setString("liveRegionStatus"_s, Protocol::Helpers::getEnumConstantValue(in_opt_liveRegionStatus));
4135 }
4136
4137 void setMouseEventNodeId(int in_opt_mouseEventNodeId)
4138 {
4139 JSON::ObjectBase::setInteger("mouseEventNodeId"_s, in_opt_mouseEventNodeId);
4140 }
4141
4142 void setOwnedNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_ownedNodeIds)
4143 {
4144 JSON::ObjectBase::setArray("ownedNodeIds"_s, WTFMove(in_opt_ownedNodeIds));
4145 }
4146
4147 void setParentNodeId(int in_opt_parentNodeId)
4148 {
4149 JSON::ObjectBase::setInteger("parentNodeId"_s, in_opt_parentNodeId);
4150 }
4151
4152 void setPressed(bool in_opt_pressed)
4153 {
4154 JSON::ObjectBase::setBoolean("pressed"_s, in_opt_pressed);
4155 }
4156
4157 void setReadonly(bool in_opt_readonly)
4158 {
4159 JSON::ObjectBase::setBoolean("readonly"_s, in_opt_readonly);
4160 }
4161
4162 void setRequired(bool in_opt_required)
4163 {
4164 JSON::ObjectBase::setBoolean("required"_s, in_opt_required);
4165 }
4166
4167 void setSelected(bool in_opt_selected)
4168 {
4169 JSON::ObjectBase::setBoolean("selected"_s, in_opt_selected);
4170 }
4171
4172 void setSelectedChildNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_selectedChildNodeIds)
4173 {
4174 JSON::ObjectBase::setArray("selectedChildNodeIds"_s, WTFMove(in_opt_selectedChildNodeIds));
4175 }
4176};
4177
4178/* A structure holding an RGBA color. */
4179class RGBAColor final : public JSON::Object {
4180public:
4181 enum {
4182 NoFieldsSet = 0,
4183 RSet = 1 << 0,
4184 GSet = 1 << 1,
4185 BSet = 1 << 2,
4186 AllFieldsSet = (RSet | GSet | BSet)
4187 };
4188
4189 template<int STATE>
4190 class Builder {
4191 private:
4192 RefPtr<JSON::Object> m_result;
4193
4194 template<int STEP> Builder<STATE | STEP>& castState()
4195 {
4196 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4197 }
4198
4199 Builder(Ref</*RGBAColor*/JSON::Object>&& object)
4200 : m_result(WTFMove(object))
4201 {
4202 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4203 }
4204 friend class RGBAColor;
4205 public:
4206
4207 Builder<STATE | RSet>& setR(int in_r)
4208 {
4209 COMPILE_ASSERT(!(STATE & RSet), property_r_already_set);
4210 m_result->setInteger("r"_s, in_r);
4211 return castState<RSet>();
4212 }
4213
4214 Builder<STATE | GSet>& setG(int in_g)
4215 {
4216 COMPILE_ASSERT(!(STATE & GSet), property_g_already_set);
4217 m_result->setInteger("g"_s, in_g);
4218 return castState<GSet>();
4219 }
4220
4221 Builder<STATE | BSet>& setB(int in_b)
4222 {
4223 COMPILE_ASSERT(!(STATE & BSet), property_b_already_set);
4224 m_result->setInteger("b"_s, in_b);
4225 return castState<BSet>();
4226 }
4227
4228 Ref<RGBAColor> release()
4229 {
4230 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4231 COMPILE_ASSERT(sizeof(RGBAColor) == sizeof(JSON::Object), cannot_cast);
4232
4233 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4234 auto result = WTFMove(*reinterpret_cast<Ref<RGBAColor>*>(&jsonResult));
4235 return result;
4236 }
4237 };
4238
4239 /*
4240 * Synthetic constructor:
4241 * Ref<RGBAColor> result = RGBAColor::create()
4242 * .setR(...)
4243 * .setG(...)
4244 * .setB(...)
4245 * .release();
4246 */
4247 static Builder<NoFieldsSet> create()
4248 {
4249 return Builder<NoFieldsSet>(JSON::Object::create());
4250 }
4251
4252 void setA(double in_opt_a)
4253 {
4254 JSON::ObjectBase::setDouble("a"_s, in_opt_a);
4255 }
4256
4257 // Property names for type generated as open.
4258 JS_EXPORT_PRIVATE static const ASCIILiteral rKey;
4259 JS_EXPORT_PRIVATE static const ASCIILiteral gKey;
4260 JS_EXPORT_PRIVATE static const ASCIILiteral bKey;
4261 JS_EXPORT_PRIVATE static const ASCIILiteral aKey;
4262};
4263
4264/* Configuration data for the highlighting of page elements. */
4265class HighlightConfig final : public JSON::Object {
4266public:
4267 enum {
4268 NoFieldsSet = 0,
4269 AllFieldsSet = 0
4270 };
4271
4272 template<int STATE>
4273 class Builder {
4274 private:
4275 RefPtr<JSON::Object> m_result;
4276
4277 template<int STEP> Builder<STATE | STEP>& castState()
4278 {
4279 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4280 }
4281
4282 Builder(Ref</*HighlightConfig*/JSON::Object>&& object)
4283 : m_result(WTFMove(object))
4284 {
4285 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4286 }
4287 friend class HighlightConfig;
4288 public:
4289
4290 Ref<HighlightConfig> release()
4291 {
4292 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4293 COMPILE_ASSERT(sizeof(HighlightConfig) == sizeof(JSON::Object), cannot_cast);
4294
4295 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4296 auto result = WTFMove(*reinterpret_cast<Ref<HighlightConfig>*>(&jsonResult));
4297 return result;
4298 }
4299 };
4300
4301 /*
4302 * Synthetic constructor:
4303 * Ref<HighlightConfig> result = HighlightConfig::create()
4304 * .release();
4305 */
4306 static Builder<NoFieldsSet> create()
4307 {
4308 return Builder<NoFieldsSet>(JSON::Object::create());
4309 }
4310
4311 void setShowInfo(bool in_opt_showInfo)
4312 {
4313 JSON::ObjectBase::setBoolean("showInfo"_s, in_opt_showInfo);
4314 }
4315
4316 void setContentColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_contentColor)
4317 {
4318 JSON::ObjectBase::setObject("contentColor"_s, WTFMove(in_opt_contentColor));
4319 }
4320
4321 void setPaddingColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_paddingColor)
4322 {
4323 JSON::ObjectBase::setObject("paddingColor"_s, WTFMove(in_opt_paddingColor));
4324 }
4325
4326 void setBorderColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_borderColor)
4327 {
4328 JSON::ObjectBase::setObject("borderColor"_s, WTFMove(in_opt_borderColor));
4329 }
4330
4331 void setMarginColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_marginColor)
4332 {
4333 JSON::ObjectBase::setObject("marginColor"_s, WTFMove(in_opt_marginColor));
4334 }
4335
4336 // Property names for type generated as open.
4337 JS_EXPORT_PRIVATE static const ASCIILiteral showInfoKey;
4338 JS_EXPORT_PRIVATE static const ASCIILiteral contentColorKey;
4339 JS_EXPORT_PRIVATE static const ASCIILiteral paddingColorKey;
4340 JS_EXPORT_PRIVATE static const ASCIILiteral borderColorKey;
4341 JS_EXPORT_PRIVATE static const ASCIILiteral marginColorKey;
4342};
4343
4344} // DOM
4345
4346namespace DOMDebugger {
4347
4348/* DOM breakpoint type. */
4349enum class DOMBreakpointType {
4350 SubtreeModified = 113,
4351 AttributeModified = 114,
4352 NodeRemoved = 115,
4353}; // enum class DOMBreakpointType
4354
4355/* Event breakpoint type. */
4356enum class EventBreakpointType {
4357 AnimationFrame = 116,
4358 Interval = 117,
4359 Listener = 118,
4360 Timeout = 119,
4361}; // enum class EventBreakpointType
4362
4363} // DOMDebugger
4364
4365namespace DOMStorage {
4366
4367/* DOM Storage identifier. */
4368class StorageId final : public JSON::Object {
4369public:
4370 enum {
4371 NoFieldsSet = 0,
4372 SecurityOriginSet = 1 << 0,
4373 IsLocalStorageSet = 1 << 1,
4374 AllFieldsSet = (SecurityOriginSet | IsLocalStorageSet)
4375 };
4376
4377 template<int STATE>
4378 class Builder {
4379 private:
4380 RefPtr<JSON::Object> m_result;
4381
4382 template<int STEP> Builder<STATE | STEP>& castState()
4383 {
4384 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4385 }
4386
4387 Builder(Ref</*StorageId*/JSON::Object>&& object)
4388 : m_result(WTFMove(object))
4389 {
4390 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4391 }
4392 friend class StorageId;
4393 public:
4394
4395 Builder<STATE | SecurityOriginSet>& setSecurityOrigin(const String& in_securityOrigin)
4396 {
4397 COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
4398 m_result->setString("securityOrigin"_s, in_securityOrigin);
4399 return castState<SecurityOriginSet>();
4400 }
4401
4402 Builder<STATE | IsLocalStorageSet>& setIsLocalStorage(bool in_isLocalStorage)
4403 {
4404 COMPILE_ASSERT(!(STATE & IsLocalStorageSet), property_isLocalStorage_already_set);
4405 m_result->setBoolean("isLocalStorage"_s, in_isLocalStorage);
4406 return castState<IsLocalStorageSet>();
4407 }
4408
4409 Ref<StorageId> release()
4410 {
4411 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4412 COMPILE_ASSERT(sizeof(StorageId) == sizeof(JSON::Object), cannot_cast);
4413
4414 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4415 auto result = WTFMove(*reinterpret_cast<Ref<StorageId>*>(&jsonResult));
4416 return result;
4417 }
4418 };
4419
4420 /*
4421 * Synthetic constructor:
4422 * Ref<StorageId> result = StorageId::create()
4423 * .setSecurityOrigin(...)
4424 * .setIsLocalStorage(...)
4425 * .release();
4426 */
4427 static Builder<NoFieldsSet> create()
4428 {
4429 return Builder<NoFieldsSet>(JSON::Object::create());
4430 }
4431
4432 // Property names for type generated as open.
4433 JS_EXPORT_PRIVATE static const ASCIILiteral securityOriginKey;
4434 JS_EXPORT_PRIVATE static const ASCIILiteral isLocalStorageKey;
4435};
4436
4437} // DOMStorage
4438
4439namespace Database {
4440
4441/* Database object. */
4442class Database final : public JSON::ObjectBase {
4443public:
4444 enum {
4445 NoFieldsSet = 0,
4446 IdSet = 1 << 0,
4447 DomainSet = 1 << 1,
4448 NameSet = 1 << 2,
4449 VersionSet = 1 << 3,
4450 AllFieldsSet = (IdSet | DomainSet | NameSet | VersionSet)
4451 };
4452
4453 template<int STATE>
4454 class Builder {
4455 private:
4456 RefPtr<JSON::Object> m_result;
4457
4458 template<int STEP> Builder<STATE | STEP>& castState()
4459 {
4460 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4461 }
4462
4463 Builder(Ref</*Database*/JSON::Object>&& object)
4464 : m_result(WTFMove(object))
4465 {
4466 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4467 }
4468 friend class Database;
4469 public:
4470
4471 Builder<STATE | IdSet>& setId(const String& in_id)
4472 {
4473 COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
4474 m_result->setString("id"_s, in_id);
4475 return castState<IdSet>();
4476 }
4477
4478 Builder<STATE | DomainSet>& setDomain(const String& in_domain)
4479 {
4480 COMPILE_ASSERT(!(STATE & DomainSet), property_domain_already_set);
4481 m_result->setString("domain"_s, in_domain);
4482 return castState<DomainSet>();
4483 }
4484
4485 Builder<STATE | NameSet>& setName(const String& in_name)
4486 {
4487 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
4488 m_result->setString("name"_s, in_name);
4489 return castState<NameSet>();
4490 }
4491
4492 Builder<STATE | VersionSet>& setVersion(const String& in_version)
4493 {
4494 COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
4495 m_result->setString("version"_s, in_version);
4496 return castState<VersionSet>();
4497 }
4498
4499 Ref<Database> release()
4500 {
4501 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4502 COMPILE_ASSERT(sizeof(Database) == sizeof(JSON::Object), cannot_cast);
4503
4504 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4505 auto result = WTFMove(*reinterpret_cast<Ref<Database>*>(&jsonResult));
4506 return result;
4507 }
4508 };
4509
4510 /*
4511 * Synthetic constructor:
4512 * Ref<Database> result = Database::create()
4513 * .setId(...)
4514 * .setDomain(...)
4515 * .setName(...)
4516 * .setVersion(...)
4517 * .release();
4518 */
4519 static Builder<NoFieldsSet> create()
4520 {
4521 return Builder<NoFieldsSet>(JSON::Object::create());
4522 }
4523};
4524
4525/* Database error. */
4526class Error final : public JSON::ObjectBase {
4527public:
4528 enum {
4529 NoFieldsSet = 0,
4530 MessageSet = 1 << 0,
4531 CodeSet = 1 << 1,
4532 AllFieldsSet = (MessageSet | CodeSet)
4533 };
4534
4535 template<int STATE>
4536 class Builder {
4537 private:
4538 RefPtr<JSON::Object> m_result;
4539
4540 template<int STEP> Builder<STATE | STEP>& castState()
4541 {
4542 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4543 }
4544
4545 Builder(Ref</*Error*/JSON::Object>&& object)
4546 : m_result(WTFMove(object))
4547 {
4548 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4549 }
4550 friend class Error;
4551 public:
4552
4553 Builder<STATE | MessageSet>& setMessage(const String& in_message)
4554 {
4555 COMPILE_ASSERT(!(STATE & MessageSet), property_message_already_set);
4556 m_result->setString("message"_s, in_message);
4557 return castState<MessageSet>();
4558 }
4559
4560 Builder<STATE | CodeSet>& setCode(int in_code)
4561 {
4562 COMPILE_ASSERT(!(STATE & CodeSet), property_code_already_set);
4563 m_result->setInteger("code"_s, in_code);
4564 return castState<CodeSet>();
4565 }
4566
4567 Ref<Error> release()
4568 {
4569 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4570 COMPILE_ASSERT(sizeof(Error) == sizeof(JSON::Object), cannot_cast);
4571
4572 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4573 auto result = WTFMove(*reinterpret_cast<Ref<Error>*>(&jsonResult));
4574 return result;
4575 }
4576 };
4577
4578 /*
4579 * Synthetic constructor:
4580 * Ref<Error> result = Error::create()
4581 * .setMessage(...)
4582 * .setCode(...)
4583 * .release();
4584 */
4585 static Builder<NoFieldsSet> create()
4586 {
4587 return Builder<NoFieldsSet>(JSON::Object::create());
4588 }
4589};
4590
4591} // Database
4592
4593namespace Debugger {
4594
4595/* Location in the source code. */
4596class Location final : public JSON::Object {
4597public:
4598 enum {
4599 NoFieldsSet = 0,
4600 ScriptIdSet = 1 << 0,
4601 LineNumberSet = 1 << 1,
4602 AllFieldsSet = (ScriptIdSet | LineNumberSet)
4603 };
4604
4605 template<int STATE>
4606 class Builder {
4607 private:
4608 RefPtr<JSON::Object> m_result;
4609
4610 template<int STEP> Builder<STATE | STEP>& castState()
4611 {
4612 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4613 }
4614
4615 Builder(Ref</*Location*/JSON::Object>&& object)
4616 : m_result(WTFMove(object))
4617 {
4618 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4619 }
4620 friend class Location;
4621 public:
4622
4623 Builder<STATE | ScriptIdSet>& setScriptId(const String& in_scriptId)
4624 {
4625 COMPILE_ASSERT(!(STATE & ScriptIdSet), property_scriptId_already_set);
4626 m_result->setString("scriptId"_s, in_scriptId);
4627 return castState<ScriptIdSet>();
4628 }
4629
4630 Builder<STATE | LineNumberSet>& setLineNumber(int in_lineNumber)
4631 {
4632 COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
4633 m_result->setInteger("lineNumber"_s, in_lineNumber);
4634 return castState<LineNumberSet>();
4635 }
4636
4637 Ref<Location> release()
4638 {
4639 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4640 COMPILE_ASSERT(sizeof(Location) == sizeof(JSON::Object), cannot_cast);
4641
4642 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4643 auto result = WTFMove(*reinterpret_cast<Ref<Location>*>(&jsonResult));
4644 return result;
4645 }
4646 };
4647
4648 /*
4649 * Synthetic constructor:
4650 * Ref<Location> result = Location::create()
4651 * .setScriptId(...)
4652 * .setLineNumber(...)
4653 * .release();
4654 */
4655 static Builder<NoFieldsSet> create()
4656 {
4657 return Builder<NoFieldsSet>(JSON::Object::create());
4658 }
4659
4660 void setColumnNumber(int in_opt_columnNumber)
4661 {
4662 JSON::ObjectBase::setInteger("columnNumber"_s, in_opt_columnNumber);
4663 }
4664
4665 // Property names for type generated as open.
4666 JS_EXPORT_PRIVATE static const ASCIILiteral scriptIdKey;
4667 JS_EXPORT_PRIVATE static const ASCIILiteral lineNumberKey;
4668 JS_EXPORT_PRIVATE static const ASCIILiteral columnNumberKey;
4669};
4670
4671/* Action to perform when a breakpoint is triggered. */
4672class BreakpointAction final : public JSON::Object {
4673public:
4674 // Named after property name 'type' while generating BreakpointAction.
4675 enum class Type {
4676 Log = 74,
4677 Evaluate = 120,
4678 Sound = 121,
4679 Probe = 122,
4680 }; // enum class Type
4681
4682 enum {
4683 NoFieldsSet = 0,
4684 TypeSet = 1 << 0,
4685 AllFieldsSet = (TypeSet)
4686 };
4687
4688 template<int STATE>
4689 class Builder {
4690 private:
4691 RefPtr<JSON::Object> m_result;
4692
4693 template<int STEP> Builder<STATE | STEP>& castState()
4694 {
4695 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4696 }
4697
4698 Builder(Ref</*BreakpointAction*/JSON::Object>&& object)
4699 : m_result(WTFMove(object))
4700 {
4701 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4702 }
4703 friend class BreakpointAction;
4704 public:
4705
4706 Builder<STATE | TypeSet>& setType(Type in_type)
4707 {
4708 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
4709 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
4710 return castState<TypeSet>();
4711 }
4712
4713 Ref<BreakpointAction> release()
4714 {
4715 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4716 COMPILE_ASSERT(sizeof(BreakpointAction) == sizeof(JSON::Object), cannot_cast);
4717
4718 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4719 auto result = WTFMove(*reinterpret_cast<Ref<BreakpointAction>*>(&jsonResult));
4720 return result;
4721 }
4722 };
4723
4724 /*
4725 * Synthetic constructor:
4726 * Ref<BreakpointAction> result = BreakpointAction::create()
4727 * .setType(...)
4728 * .release();
4729 */
4730 static Builder<NoFieldsSet> create()
4731 {
4732 return Builder<NoFieldsSet>(JSON::Object::create());
4733 }
4734
4735 void setData(const String& in_opt_data)
4736 {
4737 JSON::ObjectBase::setString("data"_s, in_opt_data);
4738 }
4739
4740 void setId(int in_opt_id)
4741 {
4742 JSON::ObjectBase::setInteger("id"_s, in_opt_id);
4743 }
4744
4745 void setEmulateUserGesture(bool in_opt_emulateUserGesture)
4746 {
4747 JSON::ObjectBase::setBoolean("emulateUserGesture"_s, in_opt_emulateUserGesture);
4748 }
4749
4750 // Property names for type generated as open.
4751 JS_EXPORT_PRIVATE static const ASCIILiteral typeKey;
4752 JS_EXPORT_PRIVATE static const ASCIILiteral dataKey;
4753 JS_EXPORT_PRIVATE static const ASCIILiteral idKey;
4754 JS_EXPORT_PRIVATE static const ASCIILiteral emulateUserGestureKey;
4755};
4756
4757/* Extra options that modify breakpoint behavior. */
4758class BreakpointOptions final : public JSON::Object {
4759public:
4760 enum {
4761 NoFieldsSet = 0,
4762 AllFieldsSet = 0
4763 };
4764
4765 template<int STATE>
4766 class Builder {
4767 private:
4768 RefPtr<JSON::Object> m_result;
4769
4770 template<int STEP> Builder<STATE | STEP>& castState()
4771 {
4772 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4773 }
4774
4775 Builder(Ref</*BreakpointOptions*/JSON::Object>&& object)
4776 : m_result(WTFMove(object))
4777 {
4778 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4779 }
4780 friend class BreakpointOptions;
4781 public:
4782
4783 Ref<BreakpointOptions> release()
4784 {
4785 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4786 COMPILE_ASSERT(sizeof(BreakpointOptions) == sizeof(JSON::Object), cannot_cast);
4787
4788 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4789 auto result = WTFMove(*reinterpret_cast<Ref<BreakpointOptions>*>(&jsonResult));
4790 return result;
4791 }
4792 };
4793
4794 /*
4795 * Synthetic constructor:
4796 * Ref<BreakpointOptions> result = BreakpointOptions::create()
4797 * .release();
4798 */
4799 static Builder<NoFieldsSet> create()
4800 {
4801 return Builder<NoFieldsSet>(JSON::Object::create());
4802 }
4803
4804 void setCondition(const String& in_opt_condition)
4805 {
4806 JSON::ObjectBase::setString("condition"_s, in_opt_condition);
4807 }
4808
4809 void setActions(Ref<JSON::ArrayOf<Protocol::Debugger::BreakpointAction>>&& in_opt_actions)
4810 {
4811 JSON::ObjectBase::setArray("actions"_s, WTFMove(in_opt_actions));
4812 }
4813
4814 void setAutoContinue(bool in_opt_autoContinue)
4815 {
4816 JSON::ObjectBase::setBoolean("autoContinue"_s, in_opt_autoContinue);
4817 }
4818
4819 void setIgnoreCount(int in_opt_ignoreCount)
4820 {
4821 JSON::ObjectBase::setInteger("ignoreCount"_s, in_opt_ignoreCount);
4822 }
4823
4824 // Property names for type generated as open.
4825 JS_EXPORT_PRIVATE static const ASCIILiteral conditionKey;
4826 JS_EXPORT_PRIVATE static const ASCIILiteral actionsKey;
4827 JS_EXPORT_PRIVATE static const ASCIILiteral autoContinueKey;
4828 JS_EXPORT_PRIVATE static const ASCIILiteral ignoreCountKey;
4829};
4830
4831/* Information about the function. */
4832class FunctionDetails final : public JSON::ObjectBase {
4833public:
4834 enum {
4835 NoFieldsSet = 0,
4836 LocationSet = 1 << 0,
4837 AllFieldsSet = (LocationSet)
4838 };
4839
4840 template<int STATE>
4841 class Builder {
4842 private:
4843 RefPtr<JSON::Object> m_result;
4844
4845 template<int STEP> Builder<STATE | STEP>& castState()
4846 {
4847 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4848 }
4849
4850 Builder(Ref</*FunctionDetails*/JSON::Object>&& object)
4851 : m_result(WTFMove(object))
4852 {
4853 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4854 }
4855 friend class FunctionDetails;
4856 public:
4857
4858 Builder<STATE | LocationSet>& setLocation(Ref<Protocol::Debugger::Location>&& in_location)
4859 {
4860 COMPILE_ASSERT(!(STATE & LocationSet), property_location_already_set);
4861 m_result->setObject("location"_s, WTFMove(in_location));
4862 return castState<LocationSet>();
4863 }
4864
4865 Ref<FunctionDetails> release()
4866 {
4867 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4868 COMPILE_ASSERT(sizeof(FunctionDetails) == sizeof(JSON::Object), cannot_cast);
4869
4870 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4871 auto result = WTFMove(*reinterpret_cast<Ref<FunctionDetails>*>(&jsonResult));
4872 return result;
4873 }
4874 };
4875
4876 /*
4877 * Synthetic constructor:
4878 * Ref<FunctionDetails> result = FunctionDetails::create()
4879 * .setLocation(...)
4880 * .release();
4881 */
4882 static Builder<NoFieldsSet> create()
4883 {
4884 return Builder<NoFieldsSet>(JSON::Object::create());
4885 }
4886
4887 void setName(const String& in_opt_name)
4888 {
4889 JSON::ObjectBase::setString("name"_s, in_opt_name);
4890 }
4891
4892 void setDisplayName(const String& in_opt_displayName)
4893 {
4894 JSON::ObjectBase::setString("displayName"_s, in_opt_displayName);
4895 }
4896
4897 void setScopeChain(Ref<JSON::ArrayOf<Protocol::Debugger::Scope>>&& in_opt_scopeChain)
4898 {
4899 JSON::ObjectBase::setArray("scopeChain"_s, WTFMove(in_opt_scopeChain));
4900 }
4901};
4902
4903/* JavaScript call frame. Array of call frames form the call stack. */
4904class CallFrame final : public JSON::ObjectBase {
4905public:
4906 enum {
4907 NoFieldsSet = 0,
4908 CallFrameIdSet = 1 << 0,
4909 FunctionNameSet = 1 << 1,
4910 LocationSet = 1 << 2,
4911 ScopeChainSet = 1 << 3,
4912 ThisSet = 1 << 4,
4913 IsTailDeletedSet = 1 << 5,
4914 AllFieldsSet = (CallFrameIdSet | FunctionNameSet | LocationSet | ScopeChainSet | ThisSet | IsTailDeletedSet)
4915 };
4916
4917 template<int STATE>
4918 class Builder {
4919 private:
4920 RefPtr<JSON::Object> m_result;
4921
4922 template<int STEP> Builder<STATE | STEP>& castState()
4923 {
4924 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4925 }
4926
4927 Builder(Ref</*CallFrame*/JSON::Object>&& object)
4928 : m_result(WTFMove(object))
4929 {
4930 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4931 }
4932 friend class CallFrame;
4933 public:
4934
4935 Builder<STATE | CallFrameIdSet>& setCallFrameId(const String& in_callFrameId)
4936 {
4937 COMPILE_ASSERT(!(STATE & CallFrameIdSet), property_callFrameId_already_set);
4938 m_result->setString("callFrameId"_s, in_callFrameId);
4939 return castState<CallFrameIdSet>();
4940 }
4941
4942 Builder<STATE | FunctionNameSet>& setFunctionName(const String& in_functionName)
4943 {
4944 COMPILE_ASSERT(!(STATE & FunctionNameSet), property_functionName_already_set);
4945 m_result->setString("functionName"_s, in_functionName);
4946 return castState<FunctionNameSet>();
4947 }
4948
4949 Builder<STATE | LocationSet>& setLocation(Ref<Protocol::Debugger::Location>&& in_location)
4950 {
4951 COMPILE_ASSERT(!(STATE & LocationSet), property_location_already_set);
4952 m_result->setObject("location"_s, WTFMove(in_location));
4953 return castState<LocationSet>();
4954 }
4955
4956 Builder<STATE | ScopeChainSet>& setScopeChain(Ref<JSON::ArrayOf<Protocol::Debugger::Scope>>&& in_scopeChain)
4957 {
4958 COMPILE_ASSERT(!(STATE & ScopeChainSet), property_scopeChain_already_set);
4959 m_result->setArray("scopeChain"_s, WTFMove(in_scopeChain));
4960 return castState<ScopeChainSet>();
4961 }
4962
4963 Builder<STATE | ThisSet>& setThis(Ref<Protocol::Runtime::RemoteObject>&& in_this)
4964 {
4965 COMPILE_ASSERT(!(STATE & ThisSet), property_this_already_set);
4966 m_result->setObject("this"_s, WTFMove(in_this));
4967 return castState<ThisSet>();
4968 }
4969
4970 Builder<STATE | IsTailDeletedSet>& setIsTailDeleted(bool in_isTailDeleted)
4971 {
4972 COMPILE_ASSERT(!(STATE & IsTailDeletedSet), property_isTailDeleted_already_set);
4973 m_result->setBoolean("isTailDeleted"_s, in_isTailDeleted);
4974 return castState<IsTailDeletedSet>();
4975 }
4976
4977 Ref<CallFrame> release()
4978 {
4979 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4980 COMPILE_ASSERT(sizeof(CallFrame) == sizeof(JSON::Object), cannot_cast);
4981
4982 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4983 auto result = WTFMove(*reinterpret_cast<Ref<CallFrame>*>(&jsonResult));
4984 return result;
4985 }
4986 };
4987
4988 /*
4989 * Synthetic constructor:
4990 * Ref<CallFrame> result = CallFrame::create()
4991 * .setCallFrameId(...)
4992 * .setFunctionName(...)
4993 * .setLocation(...)
4994 * .setScopeChain(...)
4995 * .setThis(...)
4996 * .setIsTailDeleted(...)
4997 * .release();
4998 */
4999 static Builder<NoFieldsSet> create()
5000 {
5001 return Builder<NoFieldsSet>(JSON::Object::create());
5002 }
5003};
5004
5005/* Scope description. */
5006class Scope final : public JSON::ObjectBase {
5007public:
5008 // Named after property name 'type' while generating Scope.
5009 enum class Type {
5010 Global = 123,
5011 With = 124,
5012 Closure = 125,
5013 Catch = 126,
5014 FunctionName = 127,
5015 GlobalLexicalEnvironment = 128,
5016 NestedLexical = 129,
5017 }; // enum class Type
5018
5019 enum {
5020 NoFieldsSet = 0,
5021 ObjectSet = 1 << 0,
5022 TypeSet = 1 << 1,
5023 AllFieldsSet = (ObjectSet | TypeSet)
5024 };
5025
5026 template<int STATE>
5027 class Builder {
5028 private:
5029 RefPtr<JSON::Object> m_result;
5030
5031 template<int STEP> Builder<STATE | STEP>& castState()
5032 {
5033 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5034 }
5035
5036 Builder(Ref</*Scope*/JSON::Object>&& object)
5037 : m_result(WTFMove(object))
5038 {
5039 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5040 }
5041 friend class Scope;
5042 public:
5043
5044 Builder<STATE | ObjectSet>& setObject(Ref<Protocol::Runtime::RemoteObject>&& in_object)
5045 {
5046 COMPILE_ASSERT(!(STATE & ObjectSet), property_object_already_set);
5047 m_result->setObject("object"_s, WTFMove(in_object));
5048 return castState<ObjectSet>();
5049 }
5050
5051 Builder<STATE | TypeSet>& setType(Type in_type)
5052 {
5053 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
5054 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
5055 return castState<TypeSet>();
5056 }
5057
5058 Ref<Scope> release()
5059 {
5060 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5061 COMPILE_ASSERT(sizeof(Scope) == sizeof(JSON::Object), cannot_cast);
5062
5063 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5064 auto result = WTFMove(*reinterpret_cast<Ref<Scope>*>(&jsonResult));
5065 return result;
5066 }
5067 };
5068
5069 /*
5070 * Synthetic constructor:
5071 * Ref<Scope> result = Scope::create()
5072 * .setObject(...)
5073 * .setType(...)
5074 * .release();
5075 */
5076 static Builder<NoFieldsSet> create()
5077 {
5078 return Builder<NoFieldsSet>(JSON::Object::create());
5079 }
5080
5081 void setName(const String& in_opt_name)
5082 {
5083 JSON::ObjectBase::setString("name"_s, in_opt_name);
5084 }
5085
5086 void setLocation(Ref<Protocol::Debugger::Location>&& in_opt_location)
5087 {
5088 JSON::ObjectBase::setObject("location"_s, WTFMove(in_opt_location));
5089 }
5090
5091 void setEmpty(bool in_opt_empty)
5092 {
5093 JSON::ObjectBase::setBoolean("empty"_s, in_opt_empty);
5094 }
5095};
5096
5097/* A sample collected by evaluating a probe breakpoint action. */
5098class ProbeSample final : public JSON::ObjectBase {
5099public:
5100 enum {
5101 NoFieldsSet = 0,
5102 ProbeIdSet = 1 << 0,
5103 SampleIdSet = 1 << 1,
5104 BatchIdSet = 1 << 2,
5105 TimestampSet = 1 << 3,
5106 PayloadSet = 1 << 4,
5107 AllFieldsSet = (ProbeIdSet | SampleIdSet | BatchIdSet | TimestampSet | PayloadSet)
5108 };
5109
5110 template<int STATE>
5111 class Builder {
5112 private:
5113 RefPtr<JSON::Object> m_result;
5114
5115 template<int STEP> Builder<STATE | STEP>& castState()
5116 {
5117 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5118 }
5119
5120 Builder(Ref</*ProbeSample*/JSON::Object>&& object)
5121 : m_result(WTFMove(object))
5122 {
5123 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5124 }
5125 friend class ProbeSample;
5126 public:
5127
5128 Builder<STATE | ProbeIdSet>& setProbeId(int in_probeId)
5129 {
5130 COMPILE_ASSERT(!(STATE & ProbeIdSet), property_probeId_already_set);
5131 m_result->setInteger("probeId"_s, in_probeId);
5132 return castState<ProbeIdSet>();
5133 }
5134
5135 Builder<STATE | SampleIdSet>& setSampleId(int in_sampleId)
5136 {
5137 COMPILE_ASSERT(!(STATE & SampleIdSet), property_sampleId_already_set);
5138 m_result->setInteger("sampleId"_s, in_sampleId);
5139 return castState<SampleIdSet>();
5140 }
5141
5142 Builder<STATE | BatchIdSet>& setBatchId(int in_batchId)
5143 {
5144 COMPILE_ASSERT(!(STATE & BatchIdSet), property_batchId_already_set);
5145 m_result->setInteger("batchId"_s, in_batchId);
5146 return castState<BatchIdSet>();
5147 }
5148
5149 Builder<STATE | TimestampSet>& setTimestamp(double in_timestamp)
5150 {
5151 COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
5152 m_result->setDouble("timestamp"_s, in_timestamp);
5153 return castState<TimestampSet>();
5154 }
5155
5156 Builder<STATE | PayloadSet>& setPayload(Ref<Protocol::Runtime::RemoteObject>&& in_payload)
5157 {
5158 COMPILE_ASSERT(!(STATE & PayloadSet), property_payload_already_set);
5159 m_result->setObject("payload"_s, WTFMove(in_payload));
5160 return castState<PayloadSet>();
5161 }
5162
5163 Ref<ProbeSample> release()
5164 {
5165 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5166 COMPILE_ASSERT(sizeof(ProbeSample) == sizeof(JSON::Object), cannot_cast);
5167
5168 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5169 auto result = WTFMove(*reinterpret_cast<Ref<ProbeSample>*>(&jsonResult));
5170 return result;
5171 }
5172 };
5173
5174 /*
5175 * Synthetic constructor:
5176 * Ref<ProbeSample> result = ProbeSample::create()
5177 * .setProbeId(...)
5178 * .setSampleId(...)
5179 * .setBatchId(...)
5180 * .setTimestamp(...)
5181 * .setPayload(...)
5182 * .release();
5183 */
5184 static Builder<NoFieldsSet> create()
5185 {
5186 return Builder<NoFieldsSet>(JSON::Object::create());
5187 }
5188};
5189
5190/* The pause reason auxiliary data when paused because of an assertion. */
5191class AssertPauseReason final : public JSON::ObjectBase {
5192public:
5193 enum {
5194 NoFieldsSet = 0,
5195 AllFieldsSet = 0
5196 };
5197
5198 template<int STATE>
5199 class Builder {
5200 private:
5201 RefPtr<JSON::Object> m_result;
5202
5203 template<int STEP> Builder<STATE | STEP>& castState()
5204 {
5205 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5206 }
5207
5208 Builder(Ref</*AssertPauseReason*/JSON::Object>&& object)
5209 : m_result(WTFMove(object))
5210 {
5211 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5212 }
5213 friend class AssertPauseReason;
5214 public:
5215
5216 Ref<AssertPauseReason> release()
5217 {
5218 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5219 COMPILE_ASSERT(sizeof(AssertPauseReason) == sizeof(JSON::Object), cannot_cast);
5220
5221 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5222 auto result = WTFMove(*reinterpret_cast<Ref<AssertPauseReason>*>(&jsonResult));
5223 return result;
5224 }
5225 };
5226
5227 /*
5228 * Synthetic constructor:
5229 * Ref<AssertPauseReason> result = AssertPauseReason::create()
5230 * .release();
5231 */
5232 static Builder<NoFieldsSet> create()
5233 {
5234 return Builder<NoFieldsSet>(JSON::Object::create());
5235 }
5236
5237 void setMessage(const String& in_opt_message)
5238 {
5239 JSON::ObjectBase::setString("message"_s, in_opt_message);
5240 }
5241};
5242
5243/* The pause reason auxiliary data when paused because of hitting a breakpoint. */
5244class BreakpointPauseReason final : public JSON::ObjectBase {
5245public:
5246 enum {
5247 NoFieldsSet = 0,
5248 BreakpointIdSet = 1 << 0,
5249 AllFieldsSet = (BreakpointIdSet)
5250 };
5251
5252 template<int STATE>
5253 class Builder {
5254 private:
5255 RefPtr<JSON::Object> m_result;
5256
5257 template<int STEP> Builder<STATE | STEP>& castState()
5258 {
5259 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5260 }
5261
5262 Builder(Ref</*BreakpointPauseReason*/JSON::Object>&& object)
5263 : m_result(WTFMove(object))
5264 {
5265 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5266 }
5267 friend class BreakpointPauseReason;
5268 public:
5269
5270 Builder<STATE | BreakpointIdSet>& setBreakpointId(const String& in_breakpointId)
5271 {
5272 COMPILE_ASSERT(!(STATE & BreakpointIdSet), property_breakpointId_already_set);
5273 m_result->setString("breakpointId"_s, in_breakpointId);
5274 return castState<BreakpointIdSet>();
5275 }
5276
5277 Ref<BreakpointPauseReason> release()
5278 {
5279 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5280 COMPILE_ASSERT(sizeof(BreakpointPauseReason) == sizeof(JSON::Object), cannot_cast);
5281
5282 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5283 auto result = WTFMove(*reinterpret_cast<Ref<BreakpointPauseReason>*>(&jsonResult));
5284 return result;
5285 }
5286 };
5287
5288 /*
5289 * Synthetic constructor:
5290 * Ref<BreakpointPauseReason> result = BreakpointPauseReason::create()
5291 * .setBreakpointId(...)
5292 * .release();
5293 */
5294 static Builder<NoFieldsSet> create()
5295 {
5296 return Builder<NoFieldsSet>(JSON::Object::create());
5297 }
5298};
5299
5300/* The pause reason auxiliary data when paused because of a Content Security Policy directive. */
5301class CSPViolationPauseReason final : public JSON::ObjectBase {
5302public:
5303 enum {
5304 NoFieldsSet = 0,
5305 DirectiveSet = 1 << 0,
5306 AllFieldsSet = (DirectiveSet)
5307 };
5308
5309 template<int STATE>
5310 class Builder {
5311 private:
5312 RefPtr<JSON::Object> m_result;
5313
5314 template<int STEP> Builder<STATE | STEP>& castState()
5315 {
5316 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5317 }
5318
5319 Builder(Ref</*CSPViolationPauseReason*/JSON::Object>&& object)
5320 : m_result(WTFMove(object))
5321 {
5322 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5323 }
5324 friend class CSPViolationPauseReason;
5325 public:
5326
5327 Builder<STATE | DirectiveSet>& setDirective(const String& in_directive)
5328 {
5329 COMPILE_ASSERT(!(STATE & DirectiveSet), property_directive_already_set);
5330 m_result->setString("directive"_s, in_directive);
5331 return castState<DirectiveSet>();
5332 }
5333
5334 Ref<CSPViolationPauseReason> release()
5335 {
5336 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5337 COMPILE_ASSERT(sizeof(CSPViolationPauseReason) == sizeof(JSON::Object), cannot_cast);
5338
5339 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5340 auto result = WTFMove(*reinterpret_cast<Ref<CSPViolationPauseReason>*>(&jsonResult));
5341 return result;
5342 }
5343 };
5344
5345 /*
5346 * Synthetic constructor:
5347 * Ref<CSPViolationPauseReason> result = CSPViolationPauseReason::create()
5348 * .setDirective(...)
5349 * .release();
5350 */
5351 static Builder<NoFieldsSet> create()
5352 {
5353 return Builder<NoFieldsSet>(JSON::Object::create());
5354 }
5355};
5356
5357} // Debugger
5358
5359namespace GenericTypes {
5360
5361/* Search match in a resource. */
5362class SearchMatch final : public JSON::ObjectBase {
5363public:
5364 enum {
5365 NoFieldsSet = 0,
5366 LineNumberSet = 1 << 0,
5367 LineContentSet = 1 << 1,
5368 AllFieldsSet = (LineNumberSet | LineContentSet)
5369 };
5370
5371 template<int STATE>
5372 class Builder {
5373 private:
5374 RefPtr<JSON::Object> m_result;
5375
5376 template<int STEP> Builder<STATE | STEP>& castState()
5377 {
5378 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5379 }
5380
5381 Builder(Ref</*SearchMatch*/JSON::Object>&& object)
5382 : m_result(WTFMove(object))
5383 {
5384 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5385 }
5386 friend class SearchMatch;
5387 public:
5388
5389 Builder<STATE | LineNumberSet>& setLineNumber(double in_lineNumber)
5390 {
5391 COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
5392 m_result->setDouble("lineNumber"_s, in_lineNumber);
5393 return castState<LineNumberSet>();
5394 }
5395
5396 Builder<STATE | LineContentSet>& setLineContent(const String& in_lineContent)
5397 {
5398 COMPILE_ASSERT(!(STATE & LineContentSet), property_lineContent_already_set);
5399 m_result->setString("lineContent"_s, in_lineContent);
5400 return castState<LineContentSet>();
5401 }
5402
5403 Ref<SearchMatch> release()
5404 {
5405 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5406 COMPILE_ASSERT(sizeof(SearchMatch) == sizeof(JSON::Object), cannot_cast);
5407
5408 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5409 auto result = WTFMove(*reinterpret_cast<Ref<SearchMatch>*>(&jsonResult));
5410 return result;
5411 }
5412 };
5413
5414 /*
5415 * Synthetic constructor:
5416 * Ref<SearchMatch> result = SearchMatch::create()
5417 * .setLineNumber(...)
5418 * .setLineContent(...)
5419 * .release();
5420 */
5421 static Builder<NoFieldsSet> create()
5422 {
5423 return Builder<NoFieldsSet>(JSON::Object::create());
5424 }
5425};
5426
5427} // GenericTypes
5428
5429namespace Heap {
5430
5431/* Information about a garbage collection. */
5432class GarbageCollection final : public JSON::ObjectBase {
5433public:
5434 // Named after property name 'type' while generating GarbageCollection.
5435 enum class Type {
5436 Full = 130,
5437 Partial = 131,
5438 }; // enum class Type
5439
5440 enum {
5441 NoFieldsSet = 0,
5442 TypeSet = 1 << 0,
5443 StartTimeSet = 1 << 1,
5444 EndTimeSet = 1 << 2,
5445 AllFieldsSet = (TypeSet | StartTimeSet | EndTimeSet)
5446 };
5447
5448 template<int STATE>
5449 class Builder {
5450 private:
5451 RefPtr<JSON::Object> m_result;
5452
5453 template<int STEP> Builder<STATE | STEP>& castState()
5454 {
5455 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5456 }
5457
5458 Builder(Ref</*GarbageCollection*/JSON::Object>&& object)
5459 : m_result(WTFMove(object))
5460 {
5461 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5462 }
5463 friend class GarbageCollection;
5464 public:
5465
5466 Builder<STATE | TypeSet>& setType(Type in_type)
5467 {
5468 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
5469 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
5470 return castState<TypeSet>();
5471 }
5472
5473 Builder<STATE | StartTimeSet>& setStartTime(double in_startTime)
5474 {
5475 COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
5476 m_result->setDouble("startTime"_s, in_startTime);
5477 return castState<StartTimeSet>();
5478 }
5479
5480 Builder<STATE | EndTimeSet>& setEndTime(double in_endTime)
5481 {
5482 COMPILE_ASSERT(!(STATE & EndTimeSet), property_endTime_already_set);
5483 m_result->setDouble("endTime"_s, in_endTime);
5484 return castState<EndTimeSet>();
5485 }
5486
5487 Ref<GarbageCollection> release()
5488 {
5489 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5490 COMPILE_ASSERT(sizeof(GarbageCollection) == sizeof(JSON::Object), cannot_cast);
5491
5492 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5493 auto result = WTFMove(*reinterpret_cast<Ref<GarbageCollection>*>(&jsonResult));
5494 return result;
5495 }
5496 };
5497
5498 /*
5499 * Synthetic constructor:
5500 * Ref<GarbageCollection> result = GarbageCollection::create()
5501 * .setType(...)
5502 * .setStartTime(...)
5503 * .setEndTime(...)
5504 * .release();
5505 */
5506 static Builder<NoFieldsSet> create()
5507 {
5508 return Builder<NoFieldsSet>(JSON::Object::create());
5509 }
5510};
5511
5512} // Heap
5513
5514namespace IndexedDB {
5515
5516/* Database with an array of object stores. */
5517class DatabaseWithObjectStores final : public JSON::ObjectBase {
5518public:
5519 enum {
5520 NoFieldsSet = 0,
5521 NameSet = 1 << 0,
5522 VersionSet = 1 << 1,
5523 ObjectStoresSet = 1 << 2,
5524 AllFieldsSet = (NameSet | VersionSet | ObjectStoresSet)
5525 };
5526
5527 template<int STATE>
5528 class Builder {
5529 private:
5530 RefPtr<JSON::Object> m_result;
5531
5532 template<int STEP> Builder<STATE | STEP>& castState()
5533 {
5534 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5535 }
5536
5537 Builder(Ref</*DatabaseWithObjectStores*/JSON::Object>&& object)
5538 : m_result(WTFMove(object))
5539 {
5540 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5541 }
5542 friend class DatabaseWithObjectStores;
5543 public:
5544
5545 Builder<STATE | NameSet>& setName(const String& in_name)
5546 {
5547 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
5548 m_result->setString("name"_s, in_name);
5549 return castState<NameSet>();
5550 }
5551
5552 Builder<STATE | VersionSet>& setVersion(double in_version)
5553 {
5554 COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
5555 m_result->setDouble("version"_s, in_version);
5556 return castState<VersionSet>();
5557 }
5558
5559 Builder<STATE | ObjectStoresSet>& setObjectStores(Ref<JSON::ArrayOf<Protocol::IndexedDB::ObjectStore>>&& in_objectStores)
5560 {
5561 COMPILE_ASSERT(!(STATE & ObjectStoresSet), property_objectStores_already_set);
5562 m_result->setArray("objectStores"_s, WTFMove(in_objectStores));
5563 return castState<ObjectStoresSet>();
5564 }
5565
5566 Ref<DatabaseWithObjectStores> release()
5567 {
5568 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5569 COMPILE_ASSERT(sizeof(DatabaseWithObjectStores) == sizeof(JSON::Object), cannot_cast);
5570
5571 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5572 auto result = WTFMove(*reinterpret_cast<Ref<DatabaseWithObjectStores>*>(&jsonResult));
5573 return result;
5574 }
5575 };
5576
5577 /*
5578 * Synthetic constructor:
5579 * Ref<DatabaseWithObjectStores> result = DatabaseWithObjectStores::create()
5580 * .setName(...)
5581 * .setVersion(...)
5582 * .setObjectStores(...)
5583 * .release();
5584 */
5585 static Builder<NoFieldsSet> create()
5586 {
5587 return Builder<NoFieldsSet>(JSON::Object::create());
5588 }
5589};
5590
5591/* Object store. */
5592class ObjectStore final : public JSON::ObjectBase {
5593public:
5594 enum {
5595 NoFieldsSet = 0,
5596 NameSet = 1 << 0,
5597 KeyPathSet = 1 << 1,
5598 AutoIncrementSet = 1 << 2,
5599 IndexesSet = 1 << 3,
5600 AllFieldsSet = (NameSet | KeyPathSet | AutoIncrementSet | IndexesSet)
5601 };
5602
5603 template<int STATE>
5604 class Builder {
5605 private:
5606 RefPtr<JSON::Object> m_result;
5607
5608 template<int STEP> Builder<STATE | STEP>& castState()
5609 {
5610 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5611 }
5612
5613 Builder(Ref</*ObjectStore*/JSON::Object>&& object)
5614 : m_result(WTFMove(object))
5615 {
5616 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5617 }
5618 friend class ObjectStore;
5619 public:
5620
5621 Builder<STATE | NameSet>& setName(const String& in_name)
5622 {
5623 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
5624 m_result->setString("name"_s, in_name);
5625 return castState<NameSet>();
5626 }
5627
5628 Builder<STATE | KeyPathSet>& setKeyPath(Ref<Protocol::IndexedDB::KeyPath>&& in_keyPath)
5629 {
5630 COMPILE_ASSERT(!(STATE & KeyPathSet), property_keyPath_already_set);
5631 m_result->setObject("keyPath"_s, WTFMove(in_keyPath));
5632 return castState<KeyPathSet>();
5633 }
5634
5635 Builder<STATE | AutoIncrementSet>& setAutoIncrement(bool in_autoIncrement)
5636 {
5637 COMPILE_ASSERT(!(STATE & AutoIncrementSet), property_autoIncrement_already_set);
5638 m_result->setBoolean("autoIncrement"_s, in_autoIncrement);
5639 return castState<AutoIncrementSet>();
5640 }
5641
5642 Builder<STATE | IndexesSet>& setIndexes(Ref<JSON::ArrayOf<Protocol::IndexedDB::ObjectStoreIndex>>&& in_indexes)
5643 {
5644 COMPILE_ASSERT(!(STATE & IndexesSet), property_indexes_already_set);
5645 m_result->setArray("indexes"_s, WTFMove(in_indexes));
5646 return castState<IndexesSet>();
5647 }
5648
5649 Ref<ObjectStore> release()
5650 {
5651 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5652 COMPILE_ASSERT(sizeof(ObjectStore) == sizeof(JSON::Object), cannot_cast);
5653
5654 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5655 auto result = WTFMove(*reinterpret_cast<Ref<ObjectStore>*>(&jsonResult));
5656 return result;
5657 }
5658 };
5659
5660 /*
5661 * Synthetic constructor:
5662 * Ref<ObjectStore> result = ObjectStore::create()
5663 * .setName(...)
5664 * .setKeyPath(...)
5665 * .setAutoIncrement(...)
5666 * .setIndexes(...)
5667 * .release();
5668 */
5669 static Builder<NoFieldsSet> create()
5670 {
5671 return Builder<NoFieldsSet>(JSON::Object::create());
5672 }
5673};
5674
5675/* Object store index. */
5676class ObjectStoreIndex final : public JSON::ObjectBase {
5677public:
5678 enum {
5679 NoFieldsSet = 0,
5680 NameSet = 1 << 0,
5681 KeyPathSet = 1 << 1,
5682 UniqueSet = 1 << 2,
5683 MultiEntrySet = 1 << 3,
5684 AllFieldsSet = (NameSet | KeyPathSet | UniqueSet | MultiEntrySet)
5685 };
5686
5687 template<int STATE>
5688 class Builder {
5689 private:
5690 RefPtr<JSON::Object> m_result;
5691
5692 template<int STEP> Builder<STATE | STEP>& castState()
5693 {
5694 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5695 }
5696
5697 Builder(Ref</*ObjectStoreIndex*/JSON::Object>&& object)
5698 : m_result(WTFMove(object))
5699 {
5700 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5701 }
5702 friend class ObjectStoreIndex;
5703 public:
5704
5705 Builder<STATE | NameSet>& setName(const String& in_name)
5706 {
5707 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
5708 m_result->setString("name"_s, in_name);
5709 return castState<NameSet>();
5710 }
5711
5712 Builder<STATE | KeyPathSet>& setKeyPath(Ref<Protocol::IndexedDB::KeyPath>&& in_keyPath)
5713 {
5714 COMPILE_ASSERT(!(STATE & KeyPathSet), property_keyPath_already_set);
5715 m_result->setObject("keyPath"_s, WTFMove(in_keyPath));
5716 return castState<KeyPathSet>();
5717 }
5718
5719 Builder<STATE | UniqueSet>& setUnique(bool in_unique)
5720 {
5721 COMPILE_ASSERT(!(STATE & UniqueSet), property_unique_already_set);
5722 m_result->setBoolean("unique"_s, in_unique);
5723 return castState<UniqueSet>();
5724 }
5725
5726 Builder<STATE | MultiEntrySet>& setMultiEntry(bool in_multiEntry)
5727 {
5728 COMPILE_ASSERT(!(STATE & MultiEntrySet), property_multiEntry_already_set);
5729 m_result->setBoolean("multiEntry"_s, in_multiEntry);
5730 return castState<MultiEntrySet>();
5731 }
5732
5733 Ref<ObjectStoreIndex> release()
5734 {
5735 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5736 COMPILE_ASSERT(sizeof(ObjectStoreIndex) == sizeof(JSON::Object), cannot_cast);
5737
5738 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5739 auto result = WTFMove(*reinterpret_cast<Ref<ObjectStoreIndex>*>(&jsonResult));
5740 return result;
5741 }
5742 };
5743
5744 /*
5745 * Synthetic constructor:
5746 * Ref<ObjectStoreIndex> result = ObjectStoreIndex::create()
5747 * .setName(...)
5748 * .setKeyPath(...)
5749 * .setUnique(...)
5750 * .setMultiEntry(...)
5751 * .release();
5752 */
5753 static Builder<NoFieldsSet> create()
5754 {
5755 return Builder<NoFieldsSet>(JSON::Object::create());
5756 }
5757};
5758
5759/* Key. */
5760class Key final : public JSON::Object {
5761public:
5762 // Named after property name 'type' while generating Key.
5763 enum class Type {
5764 Number = 132,
5765 String = 133,
5766 Date = 107,
5767 Array = 134,
5768 }; // enum class Type
5769
5770 enum {
5771 NoFieldsSet = 0,
5772 TypeSet = 1 << 0,
5773 AllFieldsSet = (TypeSet)
5774 };
5775
5776 template<int STATE>
5777 class Builder {
5778 private:
5779 RefPtr<JSON::Object> m_result;
5780
5781 template<int STEP> Builder<STATE | STEP>& castState()
5782 {
5783 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5784 }
5785
5786 Builder(Ref</*Key*/JSON::Object>&& object)
5787 : m_result(WTFMove(object))
5788 {
5789 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5790 }
5791 friend class Key;
5792 public:
5793
5794 Builder<STATE | TypeSet>& setType(Type in_type)
5795 {
5796 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
5797 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
5798 return castState<TypeSet>();
5799 }
5800
5801 Ref<Key> release()
5802 {
5803 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5804 COMPILE_ASSERT(sizeof(Key) == sizeof(JSON::Object), cannot_cast);
5805
5806 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5807 auto result = WTFMove(*reinterpret_cast<Ref<Key>*>(&jsonResult));
5808 return result;
5809 }
5810 };
5811
5812 /*
5813 * Synthetic constructor:
5814 * Ref<Key> result = Key::create()
5815 * .setType(...)
5816 * .release();
5817 */
5818 static Builder<NoFieldsSet> create()
5819 {
5820 return Builder<NoFieldsSet>(JSON::Object::create());
5821 }
5822
5823 void setNumber(double in_opt_number)
5824 {
5825 JSON::ObjectBase::setDouble("number"_s, in_opt_number);
5826 }
5827
5828 void setString(const String& in_opt_string)
5829 {
5830 JSON::ObjectBase::setString("string"_s, in_opt_string);
5831 }
5832
5833 void setDate(double in_opt_date)
5834 {
5835 JSON::ObjectBase::setDouble("date"_s, in_opt_date);
5836 }
5837
5838 void setArray(Ref<JSON::ArrayOf<Protocol::IndexedDB::Key>>&& in_opt_array)
5839 {
5840 JSON::ObjectBase::setArray("array"_s, WTFMove(in_opt_array));
5841 }
5842
5843 // Property names for type generated as open.
5844 JS_EXPORT_PRIVATE static const ASCIILiteral typeKey;
5845 JS_EXPORT_PRIVATE static const ASCIILiteral numberKey;
5846 JS_EXPORT_PRIVATE static const ASCIILiteral stringKey;
5847 JS_EXPORT_PRIVATE static const ASCIILiteral dateKey;
5848 JS_EXPORT_PRIVATE static const ASCIILiteral arrayKey;
5849};
5850
5851/* Key range. */
5852class KeyRange final : public JSON::Object {
5853public:
5854 enum {
5855 NoFieldsSet = 0,
5856 LowerOpenSet = 1 << 0,
5857 UpperOpenSet = 1 << 1,
5858 AllFieldsSet = (LowerOpenSet | UpperOpenSet)
5859 };
5860
5861 template<int STATE>
5862 class Builder {
5863 private:
5864 RefPtr<JSON::Object> m_result;
5865
5866 template<int STEP> Builder<STATE | STEP>& castState()
5867 {
5868 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5869 }
5870
5871 Builder(Ref</*KeyRange*/JSON::Object>&& object)
5872 : m_result(WTFMove(object))
5873 {
5874 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5875 }
5876 friend class KeyRange;
5877 public:
5878
5879 Builder<STATE | LowerOpenSet>& setLowerOpen(bool in_lowerOpen)
5880 {
5881 COMPILE_ASSERT(!(STATE & LowerOpenSet), property_lowerOpen_already_set);
5882 m_result->setBoolean("lowerOpen"_s, in_lowerOpen);
5883 return castState<LowerOpenSet>();
5884 }
5885
5886 Builder<STATE | UpperOpenSet>& setUpperOpen(bool in_upperOpen)
5887 {
5888 COMPILE_ASSERT(!(STATE & UpperOpenSet), property_upperOpen_already_set);
5889 m_result->setBoolean("upperOpen"_s, in_upperOpen);
5890 return castState<UpperOpenSet>();
5891 }
5892
5893 Ref<KeyRange> release()
5894 {
5895 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5896 COMPILE_ASSERT(sizeof(KeyRange) == sizeof(JSON::Object), cannot_cast);
5897
5898 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5899 auto result = WTFMove(*reinterpret_cast<Ref<KeyRange>*>(&jsonResult));
5900 return result;
5901 }
5902 };
5903
5904 /*
5905 * Synthetic constructor:
5906 * Ref<KeyRange> result = KeyRange::create()
5907 * .setLowerOpen(...)
5908 * .setUpperOpen(...)
5909 * .release();
5910 */
5911 static Builder<NoFieldsSet> create()
5912 {
5913 return Builder<NoFieldsSet>(JSON::Object::create());
5914 }
5915
5916 void setLower(Ref<Protocol::IndexedDB::Key>&& in_opt_lower)
5917 {
5918 JSON::ObjectBase::setObject("lower"_s, WTFMove(in_opt_lower));
5919 }
5920
5921 void setUpper(Ref<Protocol::IndexedDB::Key>&& in_opt_upper)
5922 {
5923 JSON::ObjectBase::setObject("upper"_s, WTFMove(in_opt_upper));
5924 }
5925
5926 // Property names for type generated as open.
5927 JS_EXPORT_PRIVATE static const ASCIILiteral lowerKey;
5928 JS_EXPORT_PRIVATE static const ASCIILiteral upperKey;
5929 JS_EXPORT_PRIVATE static const ASCIILiteral lowerOpenKey;
5930 JS_EXPORT_PRIVATE static const ASCIILiteral upperOpenKey;
5931};
5932
5933/* Data entry. */
5934class DataEntry final : public JSON::ObjectBase {
5935public:
5936 enum {
5937 NoFieldsSet = 0,
5938 KeySet = 1 << 0,
5939 PrimaryKeySet = 1 << 1,
5940 ValueSet = 1 << 2,
5941 AllFieldsSet = (KeySet | PrimaryKeySet | ValueSet)
5942 };
5943
5944 template<int STATE>
5945 class Builder {
5946 private:
5947 RefPtr<JSON::Object> m_result;
5948
5949 template<int STEP> Builder<STATE | STEP>& castState()
5950 {
5951 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5952 }
5953
5954 Builder(Ref</*DataEntry*/JSON::Object>&& object)
5955 : m_result(WTFMove(object))
5956 {
5957 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5958 }
5959 friend class DataEntry;
5960 public:
5961
5962 Builder<STATE | KeySet>& setKey(Ref<Protocol::Runtime::RemoteObject>&& in_key)
5963 {
5964 COMPILE_ASSERT(!(STATE & KeySet), property_key_already_set);
5965 m_result->setObject("key"_s, WTFMove(in_key));
5966 return castState<KeySet>();
5967 }
5968
5969 Builder<STATE | PrimaryKeySet>& setPrimaryKey(Ref<Protocol::Runtime::RemoteObject>&& in_primaryKey)
5970 {
5971 COMPILE_ASSERT(!(STATE & PrimaryKeySet), property_primaryKey_already_set);
5972 m_result->setObject("primaryKey"_s, WTFMove(in_primaryKey));
5973 return castState<PrimaryKeySet>();
5974 }
5975
5976 Builder<STATE | ValueSet>& setValue(Ref<Protocol::Runtime::RemoteObject>&& in_value)
5977 {
5978 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
5979 m_result->setObject("value"_s, WTFMove(in_value));
5980 return castState<ValueSet>();
5981 }
5982
5983 Ref<DataEntry> release()
5984 {
5985 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5986 COMPILE_ASSERT(sizeof(DataEntry) == sizeof(JSON::Object), cannot_cast);
5987
5988 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5989 auto result = WTFMove(*reinterpret_cast<Ref<DataEntry>*>(&jsonResult));
5990 return result;
5991 }
5992 };
5993
5994 /*
5995 * Synthetic constructor:
5996 * Ref<DataEntry> result = DataEntry::create()
5997 * .setKey(...)
5998 * .setPrimaryKey(...)
5999 * .setValue(...)
6000 * .release();
6001 */
6002 static Builder<NoFieldsSet> create()
6003 {
6004 return Builder<NoFieldsSet>(JSON::Object::create());
6005 }
6006};
6007
6008/* Key path. */
6009class KeyPath final : public JSON::ObjectBase {
6010public:
6011 // Named after property name 'type' while generating KeyPath.
6012 enum class Type {
6013 Null = 135,
6014 String = 133,
6015 Array = 134,
6016 }; // enum class Type
6017
6018 enum {
6019 NoFieldsSet = 0,
6020 TypeSet = 1 << 0,
6021 AllFieldsSet = (TypeSet)
6022 };
6023
6024 template<int STATE>
6025 class Builder {
6026 private:
6027 RefPtr<JSON::Object> m_result;
6028
6029 template<int STEP> Builder<STATE | STEP>& castState()
6030 {
6031 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6032 }
6033
6034 Builder(Ref</*KeyPath*/JSON::Object>&& object)
6035 : m_result(WTFMove(object))
6036 {
6037 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6038 }
6039 friend class KeyPath;
6040 public:
6041
6042 Builder<STATE | TypeSet>& setType(Type in_type)
6043 {
6044 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
6045 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
6046 return castState<TypeSet>();
6047 }
6048
6049 Ref<KeyPath> release()
6050 {
6051 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6052 COMPILE_ASSERT(sizeof(KeyPath) == sizeof(JSON::Object), cannot_cast);
6053
6054 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6055 auto result = WTFMove(*reinterpret_cast<Ref<KeyPath>*>(&jsonResult));
6056 return result;
6057 }
6058 };
6059
6060 /*
6061 * Synthetic constructor:
6062 * Ref<KeyPath> result = KeyPath::create()
6063 * .setType(...)
6064 * .release();
6065 */
6066 static Builder<NoFieldsSet> create()
6067 {
6068 return Builder<NoFieldsSet>(JSON::Object::create());
6069 }
6070
6071 void setString(const String& in_opt_string)
6072 {
6073 JSON::ObjectBase::setString("string"_s, in_opt_string);
6074 }
6075
6076 void setArray(Ref<JSON::ArrayOf<String>>&& in_opt_array)
6077 {
6078 JSON::ObjectBase::setArray("array"_s, WTFMove(in_opt_array));
6079 }
6080};
6081
6082} // IndexedDB
6083
6084namespace LayerTree {
6085
6086/* A rectangle. */
6087class IntRect final : public JSON::ObjectBase {
6088public:
6089 enum {
6090 NoFieldsSet = 0,
6091 XSet = 1 << 0,
6092 YSet = 1 << 1,
6093 WidthSet = 1 << 2,
6094 HeightSet = 1 << 3,
6095 AllFieldsSet = (XSet | YSet | WidthSet | HeightSet)
6096 };
6097
6098 template<int STATE>
6099 class Builder {
6100 private:
6101 RefPtr<JSON::Object> m_result;
6102
6103 template<int STEP> Builder<STATE | STEP>& castState()
6104 {
6105 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6106 }
6107
6108 Builder(Ref</*IntRect*/JSON::Object>&& object)
6109 : m_result(WTFMove(object))
6110 {
6111 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6112 }
6113 friend class IntRect;
6114 public:
6115
6116 Builder<STATE | XSet>& setX(int in_x)
6117 {
6118 COMPILE_ASSERT(!(STATE & XSet), property_x_already_set);
6119 m_result->setInteger("x"_s, in_x);
6120 return castState<XSet>();
6121 }
6122
6123 Builder<STATE | YSet>& setY(int in_y)
6124 {
6125 COMPILE_ASSERT(!(STATE & YSet), property_y_already_set);
6126 m_result->setInteger("y"_s, in_y);
6127 return castState<YSet>();
6128 }
6129
6130 Builder<STATE | WidthSet>& setWidth(int in_width)
6131 {
6132 COMPILE_ASSERT(!(STATE & WidthSet), property_width_already_set);
6133 m_result->setInteger("width"_s, in_width);
6134 return castState<WidthSet>();
6135 }
6136
6137 Builder<STATE | HeightSet>& setHeight(int in_height)
6138 {
6139 COMPILE_ASSERT(!(STATE & HeightSet), property_height_already_set);
6140 m_result->setInteger("height"_s, in_height);
6141 return castState<HeightSet>();
6142 }
6143
6144 Ref<IntRect> release()
6145 {
6146 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6147 COMPILE_ASSERT(sizeof(IntRect) == sizeof(JSON::Object), cannot_cast);
6148
6149 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6150 auto result = WTFMove(*reinterpret_cast<Ref<IntRect>*>(&jsonResult));
6151 return result;
6152 }
6153 };
6154
6155 /*
6156 * Synthetic constructor:
6157 * Ref<IntRect> result = IntRect::create()
6158 * .setX(...)
6159 * .setY(...)
6160 * .setWidth(...)
6161 * .setHeight(...)
6162 * .release();
6163 */
6164 static Builder<NoFieldsSet> create()
6165 {
6166 return Builder<NoFieldsSet>(JSON::Object::create());
6167 }
6168};
6169
6170/* Information about a compositing layer. */
6171class Layer final : public JSON::ObjectBase {
6172public:
6173 enum {
6174 NoFieldsSet = 0,
6175 LayerIdSet = 1 << 0,
6176 NodeIdSet = 1 << 1,
6177 BoundsSet = 1 << 2,
6178 PaintCountSet = 1 << 3,
6179 MemorySet = 1 << 4,
6180 CompositedBoundsSet = 1 << 5,
6181 AllFieldsSet = (LayerIdSet | NodeIdSet | BoundsSet | PaintCountSet | MemorySet | CompositedBoundsSet)
6182 };
6183
6184 template<int STATE>
6185 class Builder {
6186 private:
6187 RefPtr<JSON::Object> m_result;
6188
6189 template<int STEP> Builder<STATE | STEP>& castState()
6190 {
6191 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6192 }
6193
6194 Builder(Ref</*Layer*/JSON::Object>&& object)
6195 : m_result(WTFMove(object))
6196 {
6197 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6198 }
6199 friend class Layer;
6200 public:
6201
6202 Builder<STATE | LayerIdSet>& setLayerId(const String& in_layerId)
6203 {
6204 COMPILE_ASSERT(!(STATE & LayerIdSet), property_layerId_already_set);
6205 m_result->setString("layerId"_s, in_layerId);
6206 return castState<LayerIdSet>();
6207 }
6208
6209 Builder<STATE | NodeIdSet>& setNodeId(int in_nodeId)
6210 {
6211 COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
6212 m_result->setInteger("nodeId"_s, in_nodeId);
6213 return castState<NodeIdSet>();
6214 }
6215
6216 Builder<STATE | BoundsSet>& setBounds(Ref<Protocol::LayerTree::IntRect>&& in_bounds)
6217 {
6218 COMPILE_ASSERT(!(STATE & BoundsSet), property_bounds_already_set);
6219 m_result->setObject("bounds"_s, WTFMove(in_bounds));
6220 return castState<BoundsSet>();
6221 }
6222
6223 Builder<STATE | PaintCountSet>& setPaintCount(int in_paintCount)
6224 {
6225 COMPILE_ASSERT(!(STATE & PaintCountSet), property_paintCount_already_set);
6226 m_result->setInteger("paintCount"_s, in_paintCount);
6227 return castState<PaintCountSet>();
6228 }
6229
6230 Builder<STATE | MemorySet>& setMemory(int in_memory)
6231 {
6232 COMPILE_ASSERT(!(STATE & MemorySet), property_memory_already_set);
6233 m_result->setInteger("memory"_s, in_memory);
6234 return castState<MemorySet>();
6235 }
6236
6237 Builder<STATE | CompositedBoundsSet>& setCompositedBounds(Ref<Protocol::LayerTree::IntRect>&& in_compositedBounds)
6238 {
6239 COMPILE_ASSERT(!(STATE & CompositedBoundsSet), property_compositedBounds_already_set);
6240 m_result->setObject("compositedBounds"_s, WTFMove(in_compositedBounds));
6241 return castState<CompositedBoundsSet>();
6242 }
6243
6244 Ref<Layer> release()
6245 {
6246 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6247 COMPILE_ASSERT(sizeof(Layer) == sizeof(JSON::Object), cannot_cast);
6248
6249 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6250 auto result = WTFMove(*reinterpret_cast<Ref<Layer>*>(&jsonResult));
6251 return result;
6252 }
6253 };
6254
6255 /*
6256 * Synthetic constructor:
6257 * Ref<Layer> result = Layer::create()
6258 * .setLayerId(...)
6259 * .setNodeId(...)
6260 * .setBounds(...)
6261 * .setPaintCount(...)
6262 * .setMemory(...)
6263 * .setCompositedBounds(...)
6264 * .release();
6265 */
6266 static Builder<NoFieldsSet> create()
6267 {
6268 return Builder<NoFieldsSet>(JSON::Object::create());
6269 }
6270
6271 void setIsInShadowTree(bool in_opt_isInShadowTree)
6272 {
6273 JSON::ObjectBase::setBoolean("isInShadowTree"_s, in_opt_isInShadowTree);
6274 }
6275
6276 void setIsReflection(bool in_opt_isReflection)
6277 {
6278 JSON::ObjectBase::setBoolean("isReflection"_s, in_opt_isReflection);
6279 }
6280
6281 void setIsGeneratedContent(bool in_opt_isGeneratedContent)
6282 {
6283 JSON::ObjectBase::setBoolean("isGeneratedContent"_s, in_opt_isGeneratedContent);
6284 }
6285
6286 void setIsAnonymous(bool in_opt_isAnonymous)
6287 {
6288 JSON::ObjectBase::setBoolean("isAnonymous"_s, in_opt_isAnonymous);
6289 }
6290
6291 void setPseudoElementId(const String& in_opt_pseudoElementId)
6292 {
6293 JSON::ObjectBase::setString("pseudoElementId"_s, in_opt_pseudoElementId);
6294 }
6295
6296 void setPseudoElement(const String& in_opt_pseudoElement)
6297 {
6298 JSON::ObjectBase::setString("pseudoElement"_s, in_opt_pseudoElement);
6299 }
6300};
6301
6302/* An object containing the reasons why the layer was composited as properties. */
6303class CompositingReasons final : public JSON::ObjectBase {
6304public:
6305 enum {
6306 NoFieldsSet = 0,
6307 AllFieldsSet = 0
6308 };
6309
6310 template<int STATE>
6311 class Builder {
6312 private:
6313 RefPtr<JSON::Object> m_result;
6314
6315 template<int STEP> Builder<STATE | STEP>& castState()
6316 {
6317 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6318 }
6319
6320 Builder(Ref</*CompositingReasons*/JSON::Object>&& object)
6321 : m_result(WTFMove(object))
6322 {
6323 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6324 }
6325 friend class CompositingReasons;
6326 public:
6327
6328 Ref<CompositingReasons> release()
6329 {
6330 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6331 COMPILE_ASSERT(sizeof(CompositingReasons) == sizeof(JSON::Object), cannot_cast);
6332
6333 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6334 auto result = WTFMove(*reinterpret_cast<Ref<CompositingReasons>*>(&jsonResult));
6335 return result;
6336 }
6337 };
6338
6339 /*
6340 * Synthetic constructor:
6341 * Ref<CompositingReasons> result = CompositingReasons::create()
6342 * .release();
6343 */
6344 static Builder<NoFieldsSet> create()
6345 {
6346 return Builder<NoFieldsSet>(JSON::Object::create());
6347 }
6348
6349 void setTransform3D(bool in_opt_transform3D)
6350 {
6351 JSON::ObjectBase::setBoolean("transform3D"_s, in_opt_transform3D);
6352 }
6353
6354 void setVideo(bool in_opt_video)
6355 {
6356 JSON::ObjectBase::setBoolean("video"_s, in_opt_video);
6357 }
6358
6359 void setCanvas(bool in_opt_canvas)
6360 {
6361 JSON::ObjectBase::setBoolean("canvas"_s, in_opt_canvas);
6362 }
6363
6364 void setPlugin(bool in_opt_plugin)
6365 {
6366 JSON::ObjectBase::setBoolean("plugin"_s, in_opt_plugin);
6367 }
6368
6369 void setIFrame(bool in_opt_iFrame)
6370 {
6371 JSON::ObjectBase::setBoolean("iFrame"_s, in_opt_iFrame);
6372 }
6373
6374 void setModel(bool in_opt_model)
6375 {
6376 JSON::ObjectBase::setBoolean("model"_s, in_opt_model);
6377 }
6378
6379 void setBackfaceVisibilityHidden(bool in_opt_backfaceVisibilityHidden)
6380 {
6381 JSON::ObjectBase::setBoolean("backfaceVisibilityHidden"_s, in_opt_backfaceVisibilityHidden);
6382 }
6383
6384 void setClipsCompositingDescendants(bool in_opt_clipsCompositingDescendants)
6385 {
6386 JSON::ObjectBase::setBoolean("clipsCompositingDescendants"_s, in_opt_clipsCompositingDescendants);
6387 }
6388
6389 void setAnimation(bool in_opt_animation)
6390 {
6391 JSON::ObjectBase::setBoolean("animation"_s, in_opt_animation);
6392 }
6393
6394 void setFilters(bool in_opt_filters)
6395 {
6396 JSON::ObjectBase::setBoolean("filters"_s, in_opt_filters);
6397 }
6398
6399 void setPositionFixed(bool in_opt_positionFixed)
6400 {
6401 JSON::ObjectBase::setBoolean("positionFixed"_s, in_opt_positionFixed);
6402 }
6403
6404 void setPositionSticky(bool in_opt_positionSticky)
6405 {
6406 JSON::ObjectBase::setBoolean("positionSticky"_s, in_opt_positionSticky);
6407 }
6408
6409 void setOverflowScrollingTouch(bool in_opt_overflowScrollingTouch)
6410 {
6411 JSON::ObjectBase::setBoolean("overflowScrollingTouch"_s, in_opt_overflowScrollingTouch);
6412 }
6413
6414 void setStacking(bool in_opt_stacking)
6415 {
6416 JSON::ObjectBase::setBoolean("stacking"_s, in_opt_stacking);
6417 }
6418
6419 void setOverlap(bool in_opt_overlap)
6420 {
6421 JSON::ObjectBase::setBoolean("overlap"_s, in_opt_overlap);
6422 }
6423
6424 void setNegativeZIndexChildren(bool in_opt_negativeZIndexChildren)
6425 {
6426 JSON::ObjectBase::setBoolean("negativeZIndexChildren"_s, in_opt_negativeZIndexChildren);
6427 }
6428
6429 void setTransformWithCompositedDescendants(bool in_opt_transformWithCompositedDescendants)
6430 {
6431 JSON::ObjectBase::setBoolean("transformWithCompositedDescendants"_s, in_opt_transformWithCompositedDescendants);
6432 }
6433
6434 void setOpacityWithCompositedDescendants(bool in_opt_opacityWithCompositedDescendants)
6435 {
6436 JSON::ObjectBase::setBoolean("opacityWithCompositedDescendants"_s, in_opt_opacityWithCompositedDescendants);
6437 }
6438
6439 void setMaskWithCompositedDescendants(bool in_opt_maskWithCompositedDescendants)
6440 {
6441 JSON::ObjectBase::setBoolean("maskWithCompositedDescendants"_s, in_opt_maskWithCompositedDescendants);
6442 }
6443
6444 void setReflectionWithCompositedDescendants(bool in_opt_reflectionWithCompositedDescendants)
6445 {
6446 JSON::ObjectBase::setBoolean("reflectionWithCompositedDescendants"_s, in_opt_reflectionWithCompositedDescendants);
6447 }
6448
6449 void setFilterWithCompositedDescendants(bool in_opt_filterWithCompositedDescendants)
6450 {
6451 JSON::ObjectBase::setBoolean("filterWithCompositedDescendants"_s, in_opt_filterWithCompositedDescendants);
6452 }
6453
6454 void setBlendingWithCompositedDescendants(bool in_opt_blendingWithCompositedDescendants)
6455 {
6456 JSON::ObjectBase::setBoolean("blendingWithCompositedDescendants"_s, in_opt_blendingWithCompositedDescendants);
6457 }
6458
6459 void setIsolatesCompositedBlendingDescendants(bool in_opt_isolatesCompositedBlendingDescendants)
6460 {
6461 JSON::ObjectBase::setBoolean("isolatesCompositedBlendingDescendants"_s, in_opt_isolatesCompositedBlendingDescendants);
6462 }
6463
6464 void setPerspective(bool in_opt_perspective)
6465 {
6466 JSON::ObjectBase::setBoolean("perspective"_s, in_opt_perspective);
6467 }
6468
6469 void setPreserve3D(bool in_opt_preserve3D)
6470 {
6471 JSON::ObjectBase::setBoolean("preserve3D"_s, in_opt_preserve3D);
6472 }
6473
6474 void setWillChange(bool in_opt_willChange)
6475 {
6476 JSON::ObjectBase::setBoolean("willChange"_s, in_opt_willChange);
6477 }
6478
6479 void setRoot(bool in_opt_root)
6480 {
6481 JSON::ObjectBase::setBoolean("root"_s, in_opt_root);
6482 }
6483
6484 void setBlending(bool in_opt_blending)
6485 {
6486 JSON::ObjectBase::setBoolean("blending"_s, in_opt_blending);
6487 }
6488};
6489
6490} // LayerTree
6491
6492#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
6493namespace Memory {
6494
6495class Event final : public JSON::ObjectBase {
6496public:
6497 enum {
6498 NoFieldsSet = 0,
6499 TimestampSet = 1 << 0,
6500 CategoriesSet = 1 << 1,
6501 AllFieldsSet = (TimestampSet | CategoriesSet)
6502 };
6503
6504 template<int STATE>
6505 class Builder {
6506 private:
6507 RefPtr<JSON::Object> m_result;
6508
6509 template<int STEP> Builder<STATE | STEP>& castState()
6510 {
6511 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6512 }
6513
6514 Builder(Ref</*Event*/JSON::Object>&& object)
6515 : m_result(WTFMove(object))
6516 {
6517 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6518 }
6519 friend class Event;
6520 public:
6521
6522 Builder<STATE | TimestampSet>& setTimestamp(double in_timestamp)
6523 {
6524 COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
6525 m_result->setDouble("timestamp"_s, in_timestamp);
6526 return castState<TimestampSet>();
6527 }
6528
6529 Builder<STATE | CategoriesSet>& setCategories(Ref<JSON::ArrayOf<Protocol::Memory::CategoryData>>&& in_categories)
6530 {
6531 COMPILE_ASSERT(!(STATE & CategoriesSet), property_categories_already_set);
6532 m_result->setArray("categories"_s, WTFMove(in_categories));
6533 return castState<CategoriesSet>();
6534 }
6535
6536 Ref<Event> release()
6537 {
6538 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6539 COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast);
6540
6541 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6542 auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult));
6543 return result;
6544 }
6545 };
6546
6547 /*
6548 * Synthetic constructor:
6549 * Ref<Event> result = Event::create()
6550 * .setTimestamp(...)
6551 * .setCategories(...)
6552 * .release();
6553 */
6554 static Builder<NoFieldsSet> create()
6555 {
6556 return Builder<NoFieldsSet>(JSON::Object::create());
6557 }
6558};
6559
6560class CategoryData final : public JSON::ObjectBase {
6561public:
6562 // Named after property name 'type' while generating CategoryData.
6563 enum class Type {
6564 JavaScript = 55,
6565 JIT = 136,
6566 Images = 137,
6567 Layers = 138,
6568 Page = 104,
6569 Other = 70,
6570 }; // enum class Type
6571
6572 enum {
6573 NoFieldsSet = 0,
6574 TypeSet = 1 << 0,
6575 SizeSet = 1 << 1,
6576 AllFieldsSet = (TypeSet | SizeSet)
6577 };
6578
6579 template<int STATE>
6580 class Builder {
6581 private:
6582 RefPtr<JSON::Object> m_result;
6583
6584 template<int STEP> Builder<STATE | STEP>& castState()
6585 {
6586 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6587 }
6588
6589 Builder(Ref</*CategoryData*/JSON::Object>&& object)
6590 : m_result(WTFMove(object))
6591 {
6592 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6593 }
6594 friend class CategoryData;
6595 public:
6596
6597 Builder<STATE | TypeSet>& setType(Type in_type)
6598 {
6599 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
6600 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
6601 return castState<TypeSet>();
6602 }
6603
6604 Builder<STATE | SizeSet>& setSize(double in_size)
6605 {
6606 COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
6607 m_result->setDouble("size"_s, in_size);
6608 return castState<SizeSet>();
6609 }
6610
6611 Ref<CategoryData> release()
6612 {
6613 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6614 COMPILE_ASSERT(sizeof(CategoryData) == sizeof(JSON::Object), cannot_cast);
6615
6616 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6617 auto result = WTFMove(*reinterpret_cast<Ref<CategoryData>*>(&jsonResult));
6618 return result;
6619 }
6620 };
6621
6622 /*
6623 * Synthetic constructor:
6624 * Ref<CategoryData> result = CategoryData::create()
6625 * .setType(...)
6626 * .setSize(...)
6627 * .release();
6628 */
6629 static Builder<NoFieldsSet> create()
6630 {
6631 return Builder<NoFieldsSet>(JSON::Object::create());
6632 }
6633};
6634
6635} // Memory
6636#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
6637
6638namespace Network {
6639
6640/* Request / response headers as keys / values of JSON object. */
6641class Headers final : public JSON::ObjectBase {
6642public:
6643 enum {
6644 NoFieldsSet = 0,
6645 AllFieldsSet = 0
6646 };
6647
6648 template<int STATE>
6649 class Builder {
6650 private:
6651 RefPtr<JSON::Object> m_result;
6652
6653 template<int STEP> Builder<STATE | STEP>& castState()
6654 {
6655 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6656 }
6657
6658 Builder(Ref</*Headers*/JSON::Object>&& object)
6659 : m_result(WTFMove(object))
6660 {
6661 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6662 }
6663 friend class Headers;
6664 public:
6665
6666 Ref<Headers> release()
6667 {
6668 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6669 COMPILE_ASSERT(sizeof(Headers) == sizeof(JSON::Object), cannot_cast);
6670
6671 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6672 auto result = WTFMove(*reinterpret_cast<Ref<Headers>*>(&jsonResult));
6673 return result;
6674 }
6675 };
6676
6677 /*
6678 * Synthetic constructor:
6679 * Ref<Headers> result = Headers::create()
6680 * .release();
6681 */
6682 static Builder<NoFieldsSet> create()
6683 {
6684 return Builder<NoFieldsSet>(JSON::Object::create());
6685 }
6686};
6687
6688/* Timing information for the request. */
6689class ResourceTiming final : public JSON::ObjectBase {
6690public:
6691 enum {
6692 NoFieldsSet = 0,
6693 StartTimeSet = 1 << 0,
6694 RedirectStartSet = 1 << 1,
6695 RedirectEndSet = 1 << 2,
6696 FetchStartSet = 1 << 3,
6697 DomainLookupStartSet = 1 << 4,
6698 DomainLookupEndSet = 1 << 5,
6699 ConnectStartSet = 1 << 6,
6700 ConnectEndSet = 1 << 7,
6701 SecureConnectionStartSet = 1 << 8,
6702 RequestStartSet = 1 << 9,
6703 ResponseStartSet = 1 << 10,
6704 ResponseEndSet = 1 << 11,
6705 AllFieldsSet = (StartTimeSet | RedirectStartSet | RedirectEndSet | FetchStartSet | DomainLookupStartSet | DomainLookupEndSet | ConnectStartSet | ConnectEndSet | SecureConnectionStartSet | RequestStartSet | ResponseStartSet | ResponseEndSet)
6706 };
6707
6708 template<int STATE>
6709 class Builder {
6710 private:
6711 RefPtr<JSON::Object> m_result;
6712
6713 template<int STEP> Builder<STATE | STEP>& castState()
6714 {
6715 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6716 }
6717
6718 Builder(Ref</*ResourceTiming*/JSON::Object>&& object)
6719 : m_result(WTFMove(object))
6720 {
6721 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6722 }
6723 friend class ResourceTiming;
6724 public:
6725
6726 Builder<STATE | StartTimeSet>& setStartTime(double in_startTime)
6727 {
6728 COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
6729 m_result->setDouble("startTime"_s, in_startTime);
6730 return castState<StartTimeSet>();
6731 }
6732
6733 Builder<STATE | RedirectStartSet>& setRedirectStart(double in_redirectStart)
6734 {
6735 COMPILE_ASSERT(!(STATE & RedirectStartSet), property_redirectStart_already_set);
6736 m_result->setDouble("redirectStart"_s, in_redirectStart);
6737 return castState<RedirectStartSet>();
6738 }
6739
6740 Builder<STATE | RedirectEndSet>& setRedirectEnd(double in_redirectEnd)
6741 {
6742 COMPILE_ASSERT(!(STATE & RedirectEndSet), property_redirectEnd_already_set);
6743 m_result->setDouble("redirectEnd"_s, in_redirectEnd);
6744 return castState<RedirectEndSet>();
6745 }
6746
6747 Builder<STATE | FetchStartSet>& setFetchStart(double in_fetchStart)
6748 {
6749 COMPILE_ASSERT(!(STATE & FetchStartSet), property_fetchStart_already_set);
6750 m_result->setDouble("fetchStart"_s, in_fetchStart);
6751 return castState<FetchStartSet>();
6752 }
6753
6754 Builder<STATE | DomainLookupStartSet>& setDomainLookupStart(double in_domainLookupStart)
6755 {
6756 COMPILE_ASSERT(!(STATE & DomainLookupStartSet), property_domainLookupStart_already_set);
6757 m_result->setDouble("domainLookupStart"_s, in_domainLookupStart);
6758 return castState<DomainLookupStartSet>();
6759 }
6760
6761 Builder<STATE | DomainLookupEndSet>& setDomainLookupEnd(double in_domainLookupEnd)
6762 {
6763 COMPILE_ASSERT(!(STATE & DomainLookupEndSet), property_domainLookupEnd_already_set);
6764 m_result->setDouble("domainLookupEnd"_s, in_domainLookupEnd);
6765 return castState<DomainLookupEndSet>();
6766 }
6767
6768 Builder<STATE | ConnectStartSet>& setConnectStart(double in_connectStart)
6769 {
6770 COMPILE_ASSERT(!(STATE & ConnectStartSet), property_connectStart_already_set);
6771 m_result->setDouble("connectStart"_s, in_connectStart);
6772 return castState<ConnectStartSet>();
6773 }
6774
6775 Builder<STATE | ConnectEndSet>& setConnectEnd(double in_connectEnd)
6776 {
6777 COMPILE_ASSERT(!(STATE & ConnectEndSet), property_connectEnd_already_set);
6778 m_result->setDouble("connectEnd"_s, in_connectEnd);
6779 return castState<ConnectEndSet>();
6780 }
6781
6782 Builder<STATE | SecureConnectionStartSet>& setSecureConnectionStart(double in_secureConnectionStart)
6783 {
6784 COMPILE_ASSERT(!(STATE & SecureConnectionStartSet), property_secureConnectionStart_already_set);
6785 m_result->setDouble("secureConnectionStart"_s, in_secureConnectionStart);
6786 return castState<SecureConnectionStartSet>();
6787 }
6788
6789 Builder<STATE | RequestStartSet>& setRequestStart(double in_requestStart)
6790 {
6791 COMPILE_ASSERT(!(STATE & RequestStartSet), property_requestStart_already_set);
6792 m_result->setDouble("requestStart"_s, in_requestStart);
6793 return castState<RequestStartSet>();
6794 }
6795
6796 Builder<STATE | ResponseStartSet>& setResponseStart(double in_responseStart)
6797 {
6798 COMPILE_ASSERT(!(STATE & ResponseStartSet), property_responseStart_already_set);
6799 m_result->setDouble("responseStart"_s, in_responseStart);
6800 return castState<ResponseStartSet>();
6801 }
6802
6803 Builder<STATE | ResponseEndSet>& setResponseEnd(double in_responseEnd)
6804 {
6805 COMPILE_ASSERT(!(STATE & ResponseEndSet), property_responseEnd_already_set);
6806 m_result->setDouble("responseEnd"_s, in_responseEnd);
6807 return castState<ResponseEndSet>();
6808 }
6809
6810 Ref<ResourceTiming> release()
6811 {
6812 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6813 COMPILE_ASSERT(sizeof(ResourceTiming) == sizeof(JSON::Object), cannot_cast);
6814
6815 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6816 auto result = WTFMove(*reinterpret_cast<Ref<ResourceTiming>*>(&jsonResult));
6817 return result;
6818 }
6819 };
6820
6821 /*
6822 * Synthetic constructor:
6823 * Ref<ResourceTiming> result = ResourceTiming::create()
6824 * .setStartTime(...)
6825 * .setRedirectStart(...)
6826 * .setRedirectEnd(...)
6827 * .setFetchStart(...)
6828 * .setDomainLookupStart(...)
6829 * .setDomainLookupEnd(...)
6830 * .setConnectStart(...)
6831 * .setConnectEnd(...)
6832 * .setSecureConnectionStart(...)
6833 * .setRequestStart(...)
6834 * .setResponseStart(...)
6835 * .setResponseEnd(...)
6836 * .release();
6837 */
6838 static Builder<NoFieldsSet> create()
6839 {
6840 return Builder<NoFieldsSet>(JSON::Object::create());
6841 }
6842};
6843
6844/* HTTP request data. */
6845class Request final : public JSON::ObjectBase {
6846public:
6847 enum {
6848 NoFieldsSet = 0,
6849 UrlSet = 1 << 0,
6850 MethodSet = 1 << 1,
6851 HeadersSet = 1 << 2,
6852 AllFieldsSet = (UrlSet | MethodSet | HeadersSet)
6853 };
6854
6855 template<int STATE>
6856 class Builder {
6857 private:
6858 RefPtr<JSON::Object> m_result;
6859
6860 template<int STEP> Builder<STATE | STEP>& castState()
6861 {
6862 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6863 }
6864
6865 Builder(Ref</*Request*/JSON::Object>&& object)
6866 : m_result(WTFMove(object))
6867 {
6868 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6869 }
6870 friend class Request;
6871 public:
6872
6873 Builder<STATE | UrlSet>& setUrl(const String& in_url)
6874 {
6875 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6876 m_result->setString("url"_s, in_url);
6877 return castState<UrlSet>();
6878 }
6879
6880 Builder<STATE | MethodSet>& setMethod(const String& in_method)
6881 {
6882 COMPILE_ASSERT(!(STATE & MethodSet), property_method_already_set);
6883 m_result->setString("method"_s, in_method);
6884 return castState<MethodSet>();
6885 }
6886
6887 Builder<STATE | HeadersSet>& setHeaders(Ref<Protocol::Network::Headers>&& in_headers)
6888 {
6889 COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
6890 m_result->setObject("headers"_s, WTFMove(in_headers));
6891 return castState<HeadersSet>();
6892 }
6893
6894 Ref<Request> release()
6895 {
6896 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6897 COMPILE_ASSERT(sizeof(Request) == sizeof(JSON::Object), cannot_cast);
6898
6899 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6900 auto result = WTFMove(*reinterpret_cast<Ref<Request>*>(&jsonResult));
6901 return result;
6902 }
6903 };
6904
6905 /*
6906 * Synthetic constructor:
6907 * Ref<Request> result = Request::create()
6908 * .setUrl(...)
6909 * .setMethod(...)
6910 * .setHeaders(...)
6911 * .release();
6912 */
6913 static Builder<NoFieldsSet> create()
6914 {
6915 return Builder<NoFieldsSet>(JSON::Object::create());
6916 }
6917
6918 void setPostData(const String& in_opt_postData)
6919 {
6920 JSON::ObjectBase::setString("postData"_s, in_opt_postData);
6921 }
6922};
6923
6924/* HTTP response data. */
6925class Response final : public JSON::Object {
6926public:
6927 // Named after property name 'source' while generating Response.
6928 enum class Source {
6929 Unknown = 139,
6930 Network = 56,
6931 MemoryCache = 140,
6932 DiskCache = 141,
6933 ServiceWorker = 142,
6934 InspectorOverride = 143,
6935 }; // enum class Source
6936
6937 enum {
6938 NoFieldsSet = 0,
6939 UrlSet = 1 << 0,
6940 StatusSet = 1 << 1,
6941 StatusTextSet = 1 << 2,
6942 HeadersSet = 1 << 3,
6943 MimeTypeSet = 1 << 4,
6944 SourceSet = 1 << 5,
6945 AllFieldsSet = (UrlSet | StatusSet | StatusTextSet | HeadersSet | MimeTypeSet | SourceSet)
6946 };
6947
6948 template<int STATE>
6949 class Builder {
6950 private:
6951 RefPtr<JSON::Object> m_result;
6952
6953 template<int STEP> Builder<STATE | STEP>& castState()
6954 {
6955 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6956 }
6957
6958 Builder(Ref</*Response*/JSON::Object>&& object)
6959 : m_result(WTFMove(object))
6960 {
6961 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6962 }
6963 friend class Response;
6964 public:
6965
6966 Builder<STATE | UrlSet>& setUrl(const String& in_url)
6967 {
6968 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6969 m_result->setString("url"_s, in_url);
6970 return castState<UrlSet>();
6971 }
6972
6973 Builder<STATE | StatusSet>& setStatus(int in_status)
6974 {
6975 COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
6976 m_result->setInteger("status"_s, in_status);
6977 return castState<StatusSet>();
6978 }
6979
6980 Builder<STATE | StatusTextSet>& setStatusText(const String& in_statusText)
6981 {
6982 COMPILE_ASSERT(!(STATE & StatusTextSet), property_statusText_already_set);
6983 m_result->setString("statusText"_s, in_statusText);
6984 return castState<StatusTextSet>();
6985 }
6986
6987 Builder<STATE | HeadersSet>& setHeaders(Ref<Protocol::Network::Headers>&& in_headers)
6988 {
6989 COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
6990 m_result->setObject("headers"_s, WTFMove(in_headers));
6991 return castState<HeadersSet>();
6992 }
6993
6994 Builder<STATE | MimeTypeSet>& setMimeType(const String& in_mimeType)
6995 {
6996 COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
6997 m_result->setString("mimeType"_s, in_mimeType);
6998 return castState<MimeTypeSet>();
6999 }
7000
7001 Builder<STATE | SourceSet>& setSource(Source in_source)
7002 {
7003 COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
7004 m_result->setString("source"_s, Protocol::Helpers::getEnumConstantValue(in_source));
7005 return castState<SourceSet>();
7006 }
7007
7008 Ref<Response> release()
7009 {
7010 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7011 COMPILE_ASSERT(sizeof(Response) == sizeof(JSON::Object), cannot_cast);
7012
7013 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7014 auto result = WTFMove(*reinterpret_cast<Ref<Response>*>(&jsonResult));
7015 return result;
7016 }
7017 };
7018
7019 /*
7020 * Synthetic constructor:
7021 * Ref<Response> result = Response::create()
7022 * .setUrl(...)
7023 * .setStatus(...)
7024 * .setStatusText(...)
7025 * .setHeaders(...)
7026 * .setMimeType(...)
7027 * .setSource(...)
7028 * .release();
7029 */
7030 static Builder<NoFieldsSet> create()
7031 {
7032 return Builder<NoFieldsSet>(JSON::Object::create());
7033 }
7034
7035 void setRequestHeaders(Ref<Protocol::Network::Headers>&& in_opt_requestHeaders)
7036 {
7037 JSON::ObjectBase::setObject("requestHeaders"_s, WTFMove(in_opt_requestHeaders));
7038 }
7039
7040 void setTiming(Ref<Protocol::Network::ResourceTiming>&& in_opt_timing)
7041 {
7042 JSON::ObjectBase::setObject("timing"_s, WTFMove(in_opt_timing));
7043 }
7044
7045 void setSecurity(Ref<Protocol::Security::Security>&& in_opt_security)
7046 {
7047 JSON::ObjectBase::setObject("security"_s, WTFMove(in_opt_security));
7048 }
7049
7050 // Property names for type generated as open.
7051 JS_EXPORT_PRIVATE static const ASCIILiteral statusKey;
7052 JS_EXPORT_PRIVATE static const ASCIILiteral statusTextKey;
7053 JS_EXPORT_PRIVATE static const ASCIILiteral mimeTypeKey;
7054 JS_EXPORT_PRIVATE static const ASCIILiteral sourceKey;
7055};
7056
7057/* Network load metrics. */
7058class Metrics final : public JSON::ObjectBase {
7059public:
7060 // Named after property name 'priority' while generating Metrics.
7061 enum class Priority {
7062 Low = 144,
7063 Medium = 145,
7064 High = 146,
7065 }; // enum class Priority
7066
7067 enum {
7068 NoFieldsSet = 0,
7069 AllFieldsSet = 0
7070 };
7071
7072 template<int STATE>
7073 class Builder {
7074 private:
7075 RefPtr<JSON::Object> m_result;
7076
7077 template<int STEP> Builder<STATE | STEP>& castState()
7078 {
7079 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7080 }
7081
7082 Builder(Ref</*Metrics*/JSON::Object>&& object)
7083 : m_result(WTFMove(object))
7084 {
7085 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7086 }
7087 friend class Metrics;
7088 public:
7089
7090 Ref<Metrics> release()
7091 {
7092 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7093 COMPILE_ASSERT(sizeof(Metrics) == sizeof(JSON::Object), cannot_cast);
7094
7095 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7096 auto result = WTFMove(*reinterpret_cast<Ref<Metrics>*>(&jsonResult));
7097 return result;
7098 }
7099 };
7100
7101 /*
7102 * Synthetic constructor:
7103 * Ref<Metrics> result = Metrics::create()
7104 * .release();
7105 */
7106 static Builder<NoFieldsSet> create()
7107 {
7108 return Builder<NoFieldsSet>(JSON::Object::create());
7109 }
7110
7111 void setProtocol(const String& in_opt_protocol)
7112 {
7113 JSON::ObjectBase::setString("protocol"_s, in_opt_protocol);
7114 }
7115
7116 void setPriority(Priority in_opt_priority)
7117 {
7118 JSON::ObjectBase::setString("priority"_s, Protocol::Helpers::getEnumConstantValue(in_opt_priority));
7119 }
7120
7121 void setConnectionIdentifier(const String& in_opt_connectionIdentifier)
7122 {
7123 JSON::ObjectBase::setString("connectionIdentifier"_s, in_opt_connectionIdentifier);
7124 }
7125
7126 void setRemoteAddress(const String& in_opt_remoteAddress)
7127 {
7128 JSON::ObjectBase::setString("remoteAddress"_s, in_opt_remoteAddress);
7129 }
7130
7131 void setRequestHeaders(Ref<Protocol::Network::Headers>&& in_opt_requestHeaders)
7132 {
7133 JSON::ObjectBase::setObject("requestHeaders"_s, WTFMove(in_opt_requestHeaders));
7134 }
7135
7136 void setRequestHeaderBytesSent(double in_opt_requestHeaderBytesSent)
7137 {
7138 JSON::ObjectBase::setDouble("requestHeaderBytesSent"_s, in_opt_requestHeaderBytesSent);
7139 }
7140
7141 void setRequestBodyBytesSent(double in_opt_requestBodyBytesSent)
7142 {
7143 JSON::ObjectBase::setDouble("requestBodyBytesSent"_s, in_opt_requestBodyBytesSent);
7144 }
7145
7146 void setResponseHeaderBytesReceived(double in_opt_responseHeaderBytesReceived)
7147 {
7148 JSON::ObjectBase::setDouble("responseHeaderBytesReceived"_s, in_opt_responseHeaderBytesReceived);
7149 }
7150
7151 void setResponseBodyBytesReceived(double in_opt_responseBodyBytesReceived)
7152 {
7153 JSON::ObjectBase::setDouble("responseBodyBytesReceived"_s, in_opt_responseBodyBytesReceived);
7154 }
7155
7156 void setResponseBodyDecodedSize(double in_opt_responseBodyDecodedSize)
7157 {
7158 JSON::ObjectBase::setDouble("responseBodyDecodedSize"_s, in_opt_responseBodyDecodedSize);
7159 }
7160
7161 void setSecurityConnection(Ref<Protocol::Security::Connection>&& in_opt_securityConnection)
7162 {
7163 JSON::ObjectBase::setObject("securityConnection"_s, WTFMove(in_opt_securityConnection));
7164 }
7165};
7166
7167/* WebSocket request data. */
7168class WebSocketRequest final : public JSON::ObjectBase {
7169public:
7170 enum {
7171 NoFieldsSet = 0,
7172 HeadersSet = 1 << 0,
7173 AllFieldsSet = (HeadersSet)
7174 };
7175
7176 template<int STATE>
7177 class Builder {
7178 private:
7179 RefPtr<JSON::Object> m_result;
7180
7181 template<int STEP> Builder<STATE | STEP>& castState()
7182 {
7183 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7184 }
7185
7186 Builder(Ref</*WebSocketRequest*/JSON::Object>&& object)
7187 : m_result(WTFMove(object))
7188 {
7189 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7190 }
7191 friend class WebSocketRequest;
7192 public:
7193
7194 Builder<STATE | HeadersSet>& setHeaders(Ref<Protocol::Network::Headers>&& in_headers)
7195 {
7196 COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
7197 m_result->setObject("headers"_s, WTFMove(in_headers));
7198 return castState<HeadersSet>();
7199 }
7200
7201 Ref<WebSocketRequest> release()
7202 {
7203 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7204 COMPILE_ASSERT(sizeof(WebSocketRequest) == sizeof(JSON::Object), cannot_cast);
7205
7206 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7207 auto result = WTFMove(*reinterpret_cast<Ref<WebSocketRequest>*>(&jsonResult));
7208 return result;
7209 }
7210 };
7211
7212 /*
7213 * Synthetic constructor:
7214 * Ref<WebSocketRequest> result = WebSocketRequest::create()
7215 * .setHeaders(...)
7216 * .release();
7217 */
7218 static Builder<NoFieldsSet> create()
7219 {
7220 return Builder<NoFieldsSet>(JSON::Object::create());
7221 }
7222};
7223
7224/* WebSocket response data. */
7225class WebSocketResponse final : public JSON::ObjectBase {
7226public:
7227 enum {
7228 NoFieldsSet = 0,
7229 StatusSet = 1 << 0,
7230 StatusTextSet = 1 << 1,
7231 HeadersSet = 1 << 2,
7232 AllFieldsSet = (StatusSet | StatusTextSet | HeadersSet)
7233 };
7234
7235 template<int STATE>
7236 class Builder {
7237 private:
7238 RefPtr<JSON::Object> m_result;
7239
7240 template<int STEP> Builder<STATE | STEP>& castState()
7241 {
7242 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7243 }
7244
7245 Builder(Ref</*WebSocketResponse*/JSON::Object>&& object)
7246 : m_result(WTFMove(object))
7247 {
7248 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7249 }
7250 friend class WebSocketResponse;
7251 public:
7252
7253 Builder<STATE | StatusSet>& setStatus(int in_status)
7254 {
7255 COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
7256 m_result->setInteger("status"_s, in_status);
7257 return castState<StatusSet>();
7258 }
7259
7260 Builder<STATE | StatusTextSet>& setStatusText(const String& in_statusText)
7261 {
7262 COMPILE_ASSERT(!(STATE & StatusTextSet), property_statusText_already_set);
7263 m_result->setString("statusText"_s, in_statusText);
7264 return castState<StatusTextSet>();
7265 }
7266
7267 Builder<STATE | HeadersSet>& setHeaders(Ref<Protocol::Network::Headers>&& in_headers)
7268 {
7269 COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
7270 m_result->setObject("headers"_s, WTFMove(in_headers));
7271 return castState<HeadersSet>();
7272 }
7273
7274 Ref<WebSocketResponse> release()
7275 {
7276 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7277 COMPILE_ASSERT(sizeof(WebSocketResponse) == sizeof(JSON::Object), cannot_cast);
7278
7279 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7280 auto result = WTFMove(*reinterpret_cast<Ref<WebSocketResponse>*>(&jsonResult));
7281 return result;
7282 }
7283 };
7284
7285 /*
7286 * Synthetic constructor:
7287 * Ref<WebSocketResponse> result = WebSocketResponse::create()
7288 * .setStatus(...)
7289 * .setStatusText(...)
7290 * .setHeaders(...)
7291 * .release();
7292 */
7293 static Builder<NoFieldsSet> create()
7294 {
7295 return Builder<NoFieldsSet>(JSON::Object::create());
7296 }
7297};
7298
7299/* WebSocket frame data. */
7300class WebSocketFrame final : public JSON::ObjectBase {
7301public:
7302 enum {
7303 NoFieldsSet = 0,
7304 OpcodeSet = 1 << 0,
7305 MaskSet = 1 << 1,
7306 PayloadDataSet = 1 << 2,
7307 PayloadLengthSet = 1 << 3,
7308 AllFieldsSet = (OpcodeSet | MaskSet | PayloadDataSet | PayloadLengthSet)
7309 };
7310
7311 template<int STATE>
7312 class Builder {
7313 private:
7314 RefPtr<JSON::Object> m_result;
7315
7316 template<int STEP> Builder<STATE | STEP>& castState()
7317 {
7318 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7319 }
7320
7321 Builder(Ref</*WebSocketFrame*/JSON::Object>&& object)
7322 : m_result(WTFMove(object))
7323 {
7324 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7325 }
7326 friend class WebSocketFrame;
7327 public:
7328
7329 Builder<STATE | OpcodeSet>& setOpcode(double in_opcode)
7330 {
7331 COMPILE_ASSERT(!(STATE & OpcodeSet), property_opcode_already_set);
7332 m_result->setDouble("opcode"_s, in_opcode);
7333 return castState<OpcodeSet>();
7334 }
7335
7336 Builder<STATE | MaskSet>& setMask(bool in_mask)
7337 {
7338 COMPILE_ASSERT(!(STATE & MaskSet), property_mask_already_set);
7339 m_result->setBoolean("mask"_s, in_mask);
7340 return castState<MaskSet>();
7341 }
7342
7343 Builder<STATE | PayloadDataSet>& setPayloadData(const String& in_payloadData)
7344 {
7345 COMPILE_ASSERT(!(STATE & PayloadDataSet), property_payloadData_already_set);
7346 m_result->setString("payloadData"_s, in_payloadData);
7347 return castState<PayloadDataSet>();
7348 }
7349
7350 Builder<STATE | PayloadLengthSet>& setPayloadLength(double in_payloadLength)
7351 {
7352 COMPILE_ASSERT(!(STATE & PayloadLengthSet), property_payloadLength_already_set);
7353 m_result->setDouble("payloadLength"_s, in_payloadLength);
7354 return castState<PayloadLengthSet>();
7355 }
7356
7357 Ref<WebSocketFrame> release()
7358 {
7359 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7360 COMPILE_ASSERT(sizeof(WebSocketFrame) == sizeof(JSON::Object), cannot_cast);
7361
7362 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7363 auto result = WTFMove(*reinterpret_cast<Ref<WebSocketFrame>*>(&jsonResult));
7364 return result;
7365 }
7366 };
7367
7368 /*
7369 * Synthetic constructor:
7370 * Ref<WebSocketFrame> result = WebSocketFrame::create()
7371 * .setOpcode(...)
7372 * .setMask(...)
7373 * .setPayloadData(...)
7374 * .setPayloadLength(...)
7375 * .release();
7376 */
7377 static Builder<NoFieldsSet> create()
7378 {
7379 return Builder<NoFieldsSet>(JSON::Object::create());
7380 }
7381};
7382
7383/* Information about the cached resource. */
7384class CachedResource final : public JSON::ObjectBase {
7385public:
7386 enum {
7387 NoFieldsSet = 0,
7388 UrlSet = 1 << 0,
7389 TypeSet = 1 << 1,
7390 BodySizeSet = 1 << 2,
7391 AllFieldsSet = (UrlSet | TypeSet | BodySizeSet)
7392 };
7393
7394 template<int STATE>
7395 class Builder {
7396 private:
7397 RefPtr<JSON::Object> m_result;
7398
7399 template<int STEP> Builder<STATE | STEP>& castState()
7400 {
7401 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7402 }
7403
7404 Builder(Ref</*CachedResource*/JSON::Object>&& object)
7405 : m_result(WTFMove(object))
7406 {
7407 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7408 }
7409 friend class CachedResource;
7410 public:
7411
7412 Builder<STATE | UrlSet>& setUrl(const String& in_url)
7413 {
7414 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
7415 m_result->setString("url"_s, in_url);
7416 return castState<UrlSet>();
7417 }
7418
7419 Builder<STATE | TypeSet>& setType(Protocol::Page::ResourceType in_type)
7420 {
7421 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7422 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
7423 return castState<TypeSet>();
7424 }
7425
7426 Builder<STATE | BodySizeSet>& setBodySize(double in_bodySize)
7427 {
7428 COMPILE_ASSERT(!(STATE & BodySizeSet), property_bodySize_already_set);
7429 m_result->setDouble("bodySize"_s, in_bodySize);
7430 return castState<BodySizeSet>();
7431 }
7432
7433 Ref<CachedResource> release()
7434 {
7435 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7436 COMPILE_ASSERT(sizeof(CachedResource) == sizeof(JSON::Object), cannot_cast);
7437
7438 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7439 auto result = WTFMove(*reinterpret_cast<Ref<CachedResource>*>(&jsonResult));
7440 return result;
7441 }
7442 };
7443
7444 /*
7445 * Synthetic constructor:
7446 * Ref<CachedResource> result = CachedResource::create()
7447 * .setUrl(...)
7448 * .setType(...)
7449 * .setBodySize(...)
7450 * .release();
7451 */
7452 static Builder<NoFieldsSet> create()
7453 {
7454 return Builder<NoFieldsSet>(JSON::Object::create());
7455 }
7456
7457 void setResponse(Ref<Protocol::Network::Response>&& in_opt_response)
7458 {
7459 JSON::ObjectBase::setObject("response"_s, WTFMove(in_opt_response));
7460 }
7461
7462 void setSourceMapURL(const String& in_opt_sourceMapURL)
7463 {
7464 JSON::ObjectBase::setString("sourceMapURL"_s, in_opt_sourceMapURL);
7465 }
7466};
7467
7468/* Information about the request initiator. */
7469class Initiator final : public JSON::ObjectBase {
7470public:
7471 // Named after property name 'type' while generating Initiator.
7472 enum class Type {
7473 Parser = 158,
7474 Script = 159,
7475 Other = 70,
7476 }; // enum class Type
7477
7478 enum {
7479 NoFieldsSet = 0,
7480 TypeSet = 1 << 0,
7481 AllFieldsSet = (TypeSet)
7482 };
7483
7484 template<int STATE>
7485 class Builder {
7486 private:
7487 RefPtr<JSON::Object> m_result;
7488
7489 template<int STEP> Builder<STATE | STEP>& castState()
7490 {
7491 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7492 }
7493
7494 Builder(Ref</*Initiator*/JSON::Object>&& object)
7495 : m_result(WTFMove(object))
7496 {
7497 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7498 }
7499 friend class Initiator;
7500 public:
7501
7502 Builder<STATE | TypeSet>& setType(Type in_type)
7503 {
7504 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7505 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
7506 return castState<TypeSet>();
7507 }
7508
7509 Ref<Initiator> release()
7510 {
7511 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7512 COMPILE_ASSERT(sizeof(Initiator) == sizeof(JSON::Object), cannot_cast);
7513
7514 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7515 auto result = WTFMove(*reinterpret_cast<Ref<Initiator>*>(&jsonResult));
7516 return result;
7517 }
7518 };
7519
7520 /*
7521 * Synthetic constructor:
7522 * Ref<Initiator> result = Initiator::create()
7523 * .setType(...)
7524 * .release();
7525 */
7526 static Builder<NoFieldsSet> create()
7527 {
7528 return Builder<NoFieldsSet>(JSON::Object::create());
7529 }
7530
7531 void setStackTrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_stackTrace)
7532 {
7533 JSON::ObjectBase::setArray("stackTrace"_s, WTFMove(in_opt_stackTrace));
7534 }
7535
7536 void setUrl(const String& in_opt_url)
7537 {
7538 JSON::ObjectBase::setString("url"_s, in_opt_url);
7539 }
7540
7541 void setLineNumber(double in_opt_lineNumber)
7542 {
7543 JSON::ObjectBase::setDouble("lineNumber"_s, in_opt_lineNumber);
7544 }
7545
7546 void setNodeId(int in_opt_nodeId)
7547 {
7548 JSON::ObjectBase::setInteger("nodeId"_s, in_opt_nodeId);
7549 }
7550};
7551
7552/* Different stages of a network request. */
7553enum class NetworkStage {
7554 Request = 160,
7555 Response = 161,
7556}; // enum class NetworkStage
7557
7558/* Different stages of a network request. */
7559enum class ResourceErrorType {
7560 General = 162,
7561 AccessControl = 163,
7562 Cancellation = 164,
7563 Timeout = 165,
7564}; // enum class ResourceErrorType
7565
7566} // Network
7567
7568namespace Page {
7569
7570/* List of settings able to be overridden by WebInspector. */
7571enum class Setting {
7572 PrivateClickMeasurementDebugModeEnabled = 166,
7573 AuthorAndUserStylesEnabled = 167,
7574 ICECandidateFilteringEnabled = 168,
7575 ITPDebugModeEnabled = 169,
7576 ImagesEnabled = 170,
7577 MediaCaptureRequiresSecureConnection = 171,
7578 MockCaptureDevicesEnabled = 172,
7579 NeedsSiteSpecificQuirks = 173,
7580 ScriptEnabled = 174,
7581 ShowDebugBorders = 175,
7582 ShowRepaintCounter = 176,
7583 WebRTCEncryptionEnabled = 177,
7584 WebSecurityEnabled = 178,
7585}; // enum class Setting
7586
7587/* Resource type as it was perceived by the rendering engine. */
7588enum class ResourceType {
7589 Document = 147,
7590 StyleSheet = 148,
7591 Image = 149,
7592 Font = 150,
7593 Script = 151,
7594 XHR = 152,
7595 Fetch = 153,
7596 Ping = 154,
7597 Beacon = 155,
7598 WebSocket = 156,
7599 Other = 157,
7600}; // enum class ResourceType
7601
7602/* Coordinate system used by supplied coordinates. */
7603enum class CoordinateSystem {
7604 Viewport = 179,
7605 Page = 180,
7606}; // enum class CoordinateSystem
7607
7608/* Same-Site policy of a cookie. */
7609enum class CookieSameSitePolicy {
7610 None = 181,
7611 Lax = 182,
7612 Strict = 183,
7613}; // enum class CookieSameSitePolicy
7614
7615#if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
7616/* Page appearance name. */
7617enum class Appearance {
7618 Light = 184,
7619 Dark = 185,
7620}; // enum class Appearance
7621#endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
7622
7623/* Information about the Frame on the page. */
7624class Frame final : public JSON::ObjectBase {
7625public:
7626 enum {
7627 NoFieldsSet = 0,
7628 IdSet = 1 << 0,
7629 LoaderIdSet = 1 << 1,
7630 UrlSet = 1 << 2,
7631 SecurityOriginSet = 1 << 3,
7632 MimeTypeSet = 1 << 4,
7633 AllFieldsSet = (IdSet | LoaderIdSet | UrlSet | SecurityOriginSet | MimeTypeSet)
7634 };
7635
7636 template<int STATE>
7637 class Builder {
7638 private:
7639 RefPtr<JSON::Object> m_result;
7640
7641 template<int STEP> Builder<STATE | STEP>& castState()
7642 {
7643 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7644 }
7645
7646 Builder(Ref</*Frame*/JSON::Object>&& object)
7647 : m_result(WTFMove(object))
7648 {
7649 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7650 }
7651 friend class Frame;
7652 public:
7653
7654 Builder<STATE | IdSet>& setId(const String& in_id)
7655 {
7656 COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
7657 m_result->setString("id"_s, in_id);
7658 return castState<IdSet>();
7659 }
7660
7661 Builder<STATE | LoaderIdSet>& setLoaderId(const String& in_loaderId)
7662 {
7663 COMPILE_ASSERT(!(STATE & LoaderIdSet), property_loaderId_already_set);
7664 m_result->setString("loaderId"_s, in_loaderId);
7665 return castState<LoaderIdSet>();
7666 }
7667
7668 Builder<STATE | UrlSet>& setUrl(const String& in_url)
7669 {
7670 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
7671 m_result->setString("url"_s, in_url);
7672 return castState<UrlSet>();
7673 }
7674
7675 Builder<STATE | SecurityOriginSet>& setSecurityOrigin(const String& in_securityOrigin)
7676 {
7677 COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
7678 m_result->setString("securityOrigin"_s, in_securityOrigin);
7679 return castState<SecurityOriginSet>();
7680 }
7681
7682 Builder<STATE | MimeTypeSet>& setMimeType(const String& in_mimeType)
7683 {
7684 COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
7685 m_result->setString("mimeType"_s, in_mimeType);
7686 return castState<MimeTypeSet>();
7687 }
7688
7689 Ref<Frame> release()
7690 {
7691 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7692 COMPILE_ASSERT(sizeof(Frame) == sizeof(JSON::Object), cannot_cast);
7693
7694 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7695 auto result = WTFMove(*reinterpret_cast<Ref<Frame>*>(&jsonResult));
7696 return result;
7697 }
7698 };
7699
7700 /*
7701 * Synthetic constructor:
7702 * Ref<Frame> result = Frame::create()
7703 * .setId(...)
7704 * .setLoaderId(...)
7705 * .setUrl(...)
7706 * .setSecurityOrigin(...)
7707 * .setMimeType(...)
7708 * .release();
7709 */
7710 static Builder<NoFieldsSet> create()
7711 {
7712 return Builder<NoFieldsSet>(JSON::Object::create());
7713 }
7714
7715 void setParentId(const String& in_opt_parentId)
7716 {
7717 JSON::ObjectBase::setString("parentId"_s, in_opt_parentId);
7718 }
7719
7720 void setName(const String& in_opt_name)
7721 {
7722 JSON::ObjectBase::setString("name"_s, in_opt_name);
7723 }
7724};
7725
7726class FrameResource final : public JSON::ObjectBase {
7727public:
7728 enum {
7729 NoFieldsSet = 0,
7730 UrlSet = 1 << 0,
7731 TypeSet = 1 << 1,
7732 MimeTypeSet = 1 << 2,
7733 AllFieldsSet = (UrlSet | TypeSet | MimeTypeSet)
7734 };
7735
7736 template<int STATE>
7737 class Builder {
7738 private:
7739 RefPtr<JSON::Object> m_result;
7740
7741 template<int STEP> Builder<STATE | STEP>& castState()
7742 {
7743 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7744 }
7745
7746 Builder(Ref</*FrameResource*/JSON::Object>&& object)
7747 : m_result(WTFMove(object))
7748 {
7749 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7750 }
7751 friend class FrameResource;
7752 public:
7753
7754 Builder<STATE | UrlSet>& setUrl(const String& in_url)
7755 {
7756 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
7757 m_result->setString("url"_s, in_url);
7758 return castState<UrlSet>();
7759 }
7760
7761 Builder<STATE | TypeSet>& setType(Protocol::Page::ResourceType in_type)
7762 {
7763 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7764 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
7765 return castState<TypeSet>();
7766 }
7767
7768 Builder<STATE | MimeTypeSet>& setMimeType(const String& in_mimeType)
7769 {
7770 COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
7771 m_result->setString("mimeType"_s, in_mimeType);
7772 return castState<MimeTypeSet>();
7773 }
7774
7775 Ref<FrameResource> release()
7776 {
7777 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7778 COMPILE_ASSERT(sizeof(FrameResource) == sizeof(JSON::Object), cannot_cast);
7779
7780 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7781 auto result = WTFMove(*reinterpret_cast<Ref<FrameResource>*>(&jsonResult));
7782 return result;
7783 }
7784 };
7785
7786 /*
7787 * Synthetic constructor:
7788 * Ref<FrameResource> result = FrameResource::create()
7789 * .setUrl(...)
7790 * .setType(...)
7791 * .setMimeType(...)
7792 * .release();
7793 */
7794 static Builder<NoFieldsSet> create()
7795 {
7796 return Builder<NoFieldsSet>(JSON::Object::create());
7797 }
7798
7799 void setFailed(bool in_opt_failed)
7800 {
7801 JSON::ObjectBase::setBoolean("failed"_s, in_opt_failed);
7802 }
7803
7804 void setCanceled(bool in_opt_canceled)
7805 {
7806 JSON::ObjectBase::setBoolean("canceled"_s, in_opt_canceled);
7807 }
7808
7809 void setSourceMapURL(const String& in_opt_sourceMapURL)
7810 {
7811 JSON::ObjectBase::setString("sourceMapURL"_s, in_opt_sourceMapURL);
7812 }
7813
7814 void setTargetId(const String& in_opt_targetId)
7815 {
7816 JSON::ObjectBase::setString("targetId"_s, in_opt_targetId);
7817 }
7818};
7819
7820/* Information about the Frame hierarchy along with their cached resources. */
7821class FrameResourceTree final : public JSON::ObjectBase {
7822public:
7823 enum {
7824 NoFieldsSet = 0,
7825 FrameSet = 1 << 0,
7826 ResourcesSet = 1 << 1,
7827 AllFieldsSet = (FrameSet | ResourcesSet)
7828 };
7829
7830 template<int STATE>
7831 class Builder {
7832 private:
7833 RefPtr<JSON::Object> m_result;
7834
7835 template<int STEP> Builder<STATE | STEP>& castState()
7836 {
7837 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7838 }
7839
7840 Builder(Ref</*FrameResourceTree*/JSON::Object>&& object)
7841 : m_result(WTFMove(object))
7842 {
7843 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7844 }
7845 friend class FrameResourceTree;
7846 public:
7847
7848 Builder<STATE | FrameSet>& setFrame(Ref<Protocol::Page::Frame>&& in_frame)
7849 {
7850 COMPILE_ASSERT(!(STATE & FrameSet), property_frame_already_set);
7851 m_result->setObject("frame"_s, WTFMove(in_frame));
7852 return castState<FrameSet>();
7853 }
7854
7855 Builder<STATE | ResourcesSet>& setResources(Ref<JSON::ArrayOf<Protocol::Page::FrameResource>>&& in_resources)
7856 {
7857 COMPILE_ASSERT(!(STATE & ResourcesSet), property_resources_already_set);
7858 m_result->setArray("resources"_s, WTFMove(in_resources));
7859 return castState<ResourcesSet>();
7860 }
7861
7862 Ref<FrameResourceTree> release()
7863 {
7864 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7865 COMPILE_ASSERT(sizeof(FrameResourceTree) == sizeof(JSON::Object), cannot_cast);
7866
7867 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7868 auto result = WTFMove(*reinterpret_cast<Ref<FrameResourceTree>*>(&jsonResult));
7869 return result;
7870 }
7871 };
7872
7873 /*
7874 * Synthetic constructor:
7875 * Ref<FrameResourceTree> result = FrameResourceTree::create()
7876 * .setFrame(...)
7877 * .setResources(...)
7878 * .release();
7879 */
7880 static Builder<NoFieldsSet> create()
7881 {
7882 return Builder<NoFieldsSet>(JSON::Object::create());
7883 }
7884
7885 void setChildFrames(Ref<JSON::ArrayOf<Protocol::Page::FrameResourceTree>>&& in_opt_childFrames)
7886 {
7887 JSON::ObjectBase::setArray("childFrames"_s, WTFMove(in_opt_childFrames));
7888 }
7889};
7890
7891/* Search result for resource. */
7892class SearchResult final : public JSON::ObjectBase {
7893public:
7894 enum {
7895 NoFieldsSet = 0,
7896 UrlSet = 1 << 0,
7897 FrameIdSet = 1 << 1,
7898 MatchesCountSet = 1 << 2,
7899 AllFieldsSet = (UrlSet | FrameIdSet | MatchesCountSet)
7900 };
7901
7902 template<int STATE>
7903 class Builder {
7904 private:
7905 RefPtr<JSON::Object> m_result;
7906
7907 template<int STEP> Builder<STATE | STEP>& castState()
7908 {
7909 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7910 }
7911
7912 Builder(Ref</*SearchResult*/JSON::Object>&& object)
7913 : m_result(WTFMove(object))
7914 {
7915 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7916 }
7917 friend class SearchResult;
7918 public:
7919
7920 Builder<STATE | UrlSet>& setUrl(const String& in_url)
7921 {
7922 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
7923 m_result->setString("url"_s, in_url);
7924 return castState<UrlSet>();
7925 }
7926
7927 Builder<STATE | FrameIdSet>& setFrameId(const String& in_frameId)
7928 {
7929 COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
7930 m_result->setString("frameId"_s, in_frameId);
7931 return castState<FrameIdSet>();
7932 }
7933
7934 Builder<STATE | MatchesCountSet>& setMatchesCount(double in_matchesCount)
7935 {
7936 COMPILE_ASSERT(!(STATE & MatchesCountSet), property_matchesCount_already_set);
7937 m_result->setDouble("matchesCount"_s, in_matchesCount);
7938 return castState<MatchesCountSet>();
7939 }
7940
7941 Ref<SearchResult> release()
7942 {
7943 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7944 COMPILE_ASSERT(sizeof(SearchResult) == sizeof(JSON::Object), cannot_cast);
7945
7946 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7947 auto result = WTFMove(*reinterpret_cast<Ref<SearchResult>*>(&jsonResult));
7948 return result;
7949 }
7950 };
7951
7952 /*
7953 * Synthetic constructor:
7954 * Ref<SearchResult> result = SearchResult::create()
7955 * .setUrl(...)
7956 * .setFrameId(...)
7957 * .setMatchesCount(...)
7958 * .release();
7959 */
7960 static Builder<NoFieldsSet> create()
7961 {
7962 return Builder<NoFieldsSet>(JSON::Object::create());
7963 }
7964
7965 void setRequestId(const String& in_opt_requestId)
7966 {
7967 JSON::ObjectBase::setString("requestId"_s, in_opt_requestId);
7968 }
7969};
7970
7971/* Cookie object */
7972class Cookie final : public JSON::Object {
7973public:
7974 enum {
7975 NoFieldsSet = 0,
7976 NameSet = 1 << 0,
7977 ValueSet = 1 << 1,
7978 DomainSet = 1 << 2,
7979 PathSet = 1 << 3,
7980 ExpiresSet = 1 << 4,
7981 SessionSet = 1 << 5,
7982 HttpOnlySet = 1 << 6,
7983 SecureSet = 1 << 7,
7984 SameSiteSet = 1 << 8,
7985 AllFieldsSet = (NameSet | ValueSet | DomainSet | PathSet | ExpiresSet | SessionSet | HttpOnlySet | SecureSet | SameSiteSet)
7986 };
7987
7988 template<int STATE>
7989 class Builder {
7990 private:
7991 RefPtr<JSON::Object> m_result;
7992
7993 template<int STEP> Builder<STATE | STEP>& castState()
7994 {
7995 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7996 }
7997
7998 Builder(Ref</*Cookie*/JSON::Object>&& object)
7999 : m_result(WTFMove(object))
8000 {
8001 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8002 }
8003 friend class Cookie;
8004 public:
8005
8006 Builder<STATE | NameSet>& setName(const String& in_name)
8007 {
8008 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8009 m_result->setString("name"_s, in_name);
8010 return castState<NameSet>();
8011 }
8012
8013 Builder<STATE | ValueSet>& setValue(const String& in_value)
8014 {
8015 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
8016 m_result->setString("value"_s, in_value);
8017 return castState<ValueSet>();
8018 }
8019
8020 Builder<STATE | DomainSet>& setDomain(const String& in_domain)
8021 {
8022 COMPILE_ASSERT(!(STATE & DomainSet), property_domain_already_set);
8023 m_result->setString("domain"_s, in_domain);
8024 return castState<DomainSet>();
8025 }
8026
8027 Builder<STATE | PathSet>& setPath(const String& in_path)
8028 {
8029 COMPILE_ASSERT(!(STATE & PathSet), property_path_already_set);
8030 m_result->setString("path"_s, in_path);
8031 return castState<PathSet>();
8032 }
8033
8034 Builder<STATE | ExpiresSet>& setExpires(double in_expires)
8035 {
8036 COMPILE_ASSERT(!(STATE & ExpiresSet), property_expires_already_set);
8037 m_result->setDouble("expires"_s, in_expires);
8038 return castState<ExpiresSet>();
8039 }
8040
8041 Builder<STATE | SessionSet>& setSession(bool in_session)
8042 {
8043 COMPILE_ASSERT(!(STATE & SessionSet), property_session_already_set);
8044 m_result->setBoolean("session"_s, in_session);
8045 return castState<SessionSet>();
8046 }
8047
8048 Builder<STATE | HttpOnlySet>& setHttpOnly(bool in_httpOnly)
8049 {
8050 COMPILE_ASSERT(!(STATE & HttpOnlySet), property_httpOnly_already_set);
8051 m_result->setBoolean("httpOnly"_s, in_httpOnly);
8052 return castState<HttpOnlySet>();
8053 }
8054
8055 Builder<STATE | SecureSet>& setSecure(bool in_secure)
8056 {
8057 COMPILE_ASSERT(!(STATE & SecureSet), property_secure_already_set);
8058 m_result->setBoolean("secure"_s, in_secure);
8059 return castState<SecureSet>();
8060 }
8061
8062 Builder<STATE | SameSiteSet>& setSameSite(Protocol::Page::CookieSameSitePolicy in_sameSite)
8063 {
8064 COMPILE_ASSERT(!(STATE & SameSiteSet), property_sameSite_already_set);
8065 m_result->setString("sameSite"_s, Protocol::Helpers::getEnumConstantValue(in_sameSite));
8066 return castState<SameSiteSet>();
8067 }
8068
8069 Ref<Cookie> release()
8070 {
8071 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8072 COMPILE_ASSERT(sizeof(Cookie) == sizeof(JSON::Object), cannot_cast);
8073
8074 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8075 auto result = WTFMove(*reinterpret_cast<Ref<Cookie>*>(&jsonResult));
8076 return result;
8077 }
8078 };
8079
8080 /*
8081 * Synthetic constructor:
8082 * Ref<Cookie> result = Cookie::create()
8083 * .setName(...)
8084 * .setValue(...)
8085 * .setDomain(...)
8086 * .setPath(...)
8087 * .setExpires(...)
8088 * .setSession(...)
8089 * .setHttpOnly(...)
8090 * .setSecure(...)
8091 * .setSameSite(...)
8092 * .release();
8093 */
8094 static Builder<NoFieldsSet> create()
8095 {
8096 return Builder<NoFieldsSet>(JSON::Object::create());
8097 }
8098
8099 // Property names for type generated as open.
8100 JS_EXPORT_PRIVATE static const ASCIILiteral nameKey;
8101 JS_EXPORT_PRIVATE static const ASCIILiteral valueKey;
8102 JS_EXPORT_PRIVATE static const ASCIILiteral domainKey;
8103 JS_EXPORT_PRIVATE static const ASCIILiteral pathKey;
8104 JS_EXPORT_PRIVATE static const ASCIILiteral expiresKey;
8105 JS_EXPORT_PRIVATE static const ASCIILiteral sessionKey;
8106 JS_EXPORT_PRIVATE static const ASCIILiteral httpOnlyKey;
8107 JS_EXPORT_PRIVATE static const ASCIILiteral secureKey;
8108 JS_EXPORT_PRIVATE static const ASCIILiteral sameSiteKey;
8109};
8110
8111} // Page
8112
8113namespace Recording {
8114
8115/* The type of the recording. */
8116enum class Type {
8117 Canvas2D = 45,
8118 CanvasBitmapRenderer = 186,
8119 CanvasWebGL = 187,
8120 CanvasWebGL2 = 188,
8121}; // enum class Type
8122
8123enum class Initiator {
8124 Frontend = 189,
8125 Console = 190,
8126 AutoCapture = 191,
8127}; // enum class Initiator
8128
8129/* Information about the initial state of the recorded object. */
8130class InitialState final : public JSON::ObjectBase {
8131public:
8132 enum {
8133 NoFieldsSet = 0,
8134 AllFieldsSet = 0
8135 };
8136
8137 template<int STATE>
8138 class Builder {
8139 private:
8140 RefPtr<JSON::Object> m_result;
8141
8142 template<int STEP> Builder<STATE | STEP>& castState()
8143 {
8144 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8145 }
8146
8147 Builder(Ref</*InitialState*/JSON::Object>&& object)
8148 : m_result(WTFMove(object))
8149 {
8150 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8151 }
8152 friend class InitialState;
8153 public:
8154
8155 Ref<InitialState> release()
8156 {
8157 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8158 COMPILE_ASSERT(sizeof(InitialState) == sizeof(JSON::Object), cannot_cast);
8159
8160 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8161 auto result = WTFMove(*reinterpret_cast<Ref<InitialState>*>(&jsonResult));
8162 return result;
8163 }
8164 };
8165
8166 /*
8167 * Synthetic constructor:
8168 * Ref<InitialState> result = InitialState::create()
8169 * .release();
8170 */
8171 static Builder<NoFieldsSet> create()
8172 {
8173 return Builder<NoFieldsSet>(JSON::Object::create());
8174 }
8175
8176 void setAttributes(Ref<JSON::Object>&& in_opt_attributes)
8177 {
8178 JSON::ObjectBase::setObject("attributes"_s, WTFMove(in_opt_attributes));
8179 }
8180
8181 void setStates(Ref<JSON::ArrayOf<JSON::Object>>&& in_opt_states)
8182 {
8183 JSON::ObjectBase::setArray("states"_s, WTFMove(in_opt_states));
8184 }
8185
8186 void setParameters(Ref<JSON::ArrayOf<JSON::Value>>&& in_opt_parameters)
8187 {
8188 JSON::ObjectBase::setArray("parameters"_s, WTFMove(in_opt_parameters));
8189 }
8190
8191 void setContent(const String& in_opt_content)
8192 {
8193 JSON::ObjectBase::setString("content"_s, in_opt_content);
8194 }
8195};
8196
8197/* Container object for a single frame of the recording. */
8198class Frame final : public JSON::ObjectBase {
8199public:
8200 enum {
8201 NoFieldsSet = 0,
8202 ActionsSet = 1 << 0,
8203 AllFieldsSet = (ActionsSet)
8204 };
8205
8206 template<int STATE>
8207 class Builder {
8208 private:
8209 RefPtr<JSON::Object> m_result;
8210
8211 template<int STEP> Builder<STATE | STEP>& castState()
8212 {
8213 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8214 }
8215
8216 Builder(Ref</*Frame*/JSON::Object>&& object)
8217 : m_result(WTFMove(object))
8218 {
8219 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8220 }
8221 friend class Frame;
8222 public:
8223
8224 Builder<STATE | ActionsSet>& setActions(Ref<JSON::ArrayOf<JSON::Value>>&& in_actions)
8225 {
8226 COMPILE_ASSERT(!(STATE & ActionsSet), property_actions_already_set);
8227 m_result->setArray("actions"_s, WTFMove(in_actions));
8228 return castState<ActionsSet>();
8229 }
8230
8231 Ref<Frame> release()
8232 {
8233 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8234 COMPILE_ASSERT(sizeof(Frame) == sizeof(JSON::Object), cannot_cast);
8235
8236 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8237 auto result = WTFMove(*reinterpret_cast<Ref<Frame>*>(&jsonResult));
8238 return result;
8239 }
8240 };
8241
8242 /*
8243 * Synthetic constructor:
8244 * Ref<Frame> result = Frame::create()
8245 * .setActions(...)
8246 * .release();
8247 */
8248 static Builder<NoFieldsSet> create()
8249 {
8250 return Builder<NoFieldsSet>(JSON::Object::create());
8251 }
8252
8253 void setDuration(double in_opt_duration)
8254 {
8255 JSON::ObjectBase::setDouble("duration"_s, in_opt_duration);
8256 }
8257
8258 void setIncomplete(bool in_opt_incomplete)
8259 {
8260 JSON::ObjectBase::setBoolean("incomplete"_s, in_opt_incomplete);
8261 }
8262};
8263
8264class Recording final : public JSON::ObjectBase {
8265public:
8266 enum {
8267 NoFieldsSet = 0,
8268 VersionSet = 1 << 0,
8269 TypeSet = 1 << 1,
8270 InitialStateSet = 1 << 2,
8271 DataSet = 1 << 3,
8272 AllFieldsSet = (VersionSet | TypeSet | InitialStateSet | DataSet)
8273 };
8274
8275 template<int STATE>
8276 class Builder {
8277 private:
8278 RefPtr<JSON::Object> m_result;
8279
8280 template<int STEP> Builder<STATE | STEP>& castState()
8281 {
8282 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8283 }
8284
8285 Builder(Ref</*Recording*/JSON::Object>&& object)
8286 : m_result(WTFMove(object))
8287 {
8288 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8289 }
8290 friend class Recording;
8291 public:
8292
8293 Builder<STATE | VersionSet>& setVersion(int in_version)
8294 {
8295 COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
8296 m_result->setInteger("version"_s, in_version);
8297 return castState<VersionSet>();
8298 }
8299
8300 Builder<STATE | TypeSet>& setType(Protocol::Recording::Type in_type)
8301 {
8302 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
8303 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
8304 return castState<TypeSet>();
8305 }
8306
8307 Builder<STATE | InitialStateSet>& setInitialState(Ref<Protocol::Recording::InitialState>&& in_initialState)
8308 {
8309 COMPILE_ASSERT(!(STATE & InitialStateSet), property_initialState_already_set);
8310 m_result->setObject("initialState"_s, WTFMove(in_initialState));
8311 return castState<InitialStateSet>();
8312 }
8313
8314 Builder<STATE | DataSet>& setData(Ref<JSON::ArrayOf<JSON::Value>>&& in_data)
8315 {
8316 COMPILE_ASSERT(!(STATE & DataSet), property_data_already_set);
8317 m_result->setArray("data"_s, WTFMove(in_data));
8318 return castState<DataSet>();
8319 }
8320
8321 Ref<Recording> release()
8322 {
8323 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8324 COMPILE_ASSERT(sizeof(Recording) == sizeof(JSON::Object), cannot_cast);
8325
8326 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8327 auto result = WTFMove(*reinterpret_cast<Ref<Recording>*>(&jsonResult));
8328 return result;
8329 }
8330 };
8331
8332 /*
8333 * Synthetic constructor:
8334 * Ref<Recording> result = Recording::create()
8335 * .setVersion(...)
8336 * .setType(...)
8337 * .setInitialState(...)
8338 * .setData(...)
8339 * .release();
8340 */
8341 static Builder<NoFieldsSet> create()
8342 {
8343 return Builder<NoFieldsSet>(JSON::Object::create());
8344 }
8345
8346 void setName(const String& in_opt_name)
8347 {
8348 JSON::ObjectBase::setString("name"_s, in_opt_name);
8349 }
8350};
8351
8352} // Recording
8353
8354namespace Runtime {
8355
8356/* Mirror object referencing original JavaScript object. */
8357class RemoteObject final : public JSON::ObjectBase {
8358public:
8359 // Named after property name 'type' while generating RemoteObject.
8360 enum class Type {
8361 Object = 192,
8362 Function = 193,
8363 Undefined = 194,
8364 String = 133,
8365 Number = 132,
8366 Boolean = 195,
8367 Symbol = 196,
8368 Bigint = 197,
8369 }; // enum class Type
8370
8371 // Named after property name 'subtype' while generating RemoteObject.
8372 enum class Subtype {
8373 Array = 134,
8374 Null = 135,
8375 Node = 198,
8376 Regexp = 199,
8377 Date = 107,
8378 Error = 77,
8379 Map = 200,
8380 Set = 201,
8381 Weakmap = 202,
8382 Weakset = 203,
8383 Iterator = 204,
8384 Class = 205,
8385 Proxy = 206,
8386 }; // enum class Subtype
8387
8388 enum {
8389 NoFieldsSet = 0,
8390 TypeSet = 1 << 0,
8391 AllFieldsSet = (TypeSet)
8392 };
8393
8394 template<int STATE>
8395 class Builder {
8396 private:
8397 RefPtr<JSON::Object> m_result;
8398
8399 template<int STEP> Builder<STATE | STEP>& castState()
8400 {
8401 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8402 }
8403
8404 Builder(Ref</*RemoteObject*/JSON::Object>&& object)
8405 : m_result(WTFMove(object))
8406 {
8407 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8408 }
8409 friend class RemoteObject;
8410 public:
8411
8412 Builder<STATE | TypeSet>& setType(Type in_type)
8413 {
8414 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
8415 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
8416 return castState<TypeSet>();
8417 }
8418
8419 Ref<RemoteObject> release()
8420 {
8421 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8422 COMPILE_ASSERT(sizeof(RemoteObject) == sizeof(JSON::Object), cannot_cast);
8423
8424 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8425 auto result = WTFMove(*reinterpret_cast<Ref<RemoteObject>*>(&jsonResult));
8426 return result;
8427 }
8428 };
8429
8430 /*
8431 * Synthetic constructor:
8432 * Ref<RemoteObject> result = RemoteObject::create()
8433 * .setType(...)
8434 * .release();
8435 */
8436 static Builder<NoFieldsSet> create()
8437 {
8438 return Builder<NoFieldsSet>(JSON::Object::create());
8439 }
8440
8441 void setSubtype(Subtype in_opt_subtype)
8442 {
8443 JSON::ObjectBase::setString("subtype"_s, Protocol::Helpers::getEnumConstantValue(in_opt_subtype));
8444 }
8445
8446 void setClassName(const String& in_opt_className)
8447 {
8448 JSON::ObjectBase::setString("className"_s, in_opt_className);
8449 }
8450
8451 void setValue(Ref<JSON::Value>&& in_opt_value)
8452 {
8453 JSON::ObjectBase::setValue("value"_s, WTFMove(in_opt_value));
8454 }
8455
8456 void setDescription(const String& in_opt_description)
8457 {
8458 JSON::ObjectBase::setString("description"_s, in_opt_description);
8459 }
8460
8461 void setObjectId(const String& in_opt_objectId)
8462 {
8463 JSON::ObjectBase::setString("objectId"_s, in_opt_objectId);
8464 }
8465
8466 void setSize(int in_opt_size)
8467 {
8468 JSON::ObjectBase::setInteger("size"_s, in_opt_size);
8469 }
8470
8471 void setClassPrototype(Ref<Protocol::Runtime::RemoteObject>&& in_opt_classPrototype)
8472 {
8473 JSON::ObjectBase::setObject("classPrototype"_s, WTFMove(in_opt_classPrototype));
8474 }
8475
8476 void setPreview(Ref<Protocol::Runtime::ObjectPreview>&& in_opt_preview)
8477 {
8478 JSON::ObjectBase::setObject("preview"_s, WTFMove(in_opt_preview));
8479 }
8480};
8481
8482/* Object containing abbreviated remote object value. */
8483class ObjectPreview final : public JSON::ObjectBase {
8484public:
8485 // Named after property name 'type' while generating ObjectPreview.
8486 enum class Type {
8487 Object = 192,
8488 Function = 193,
8489 Undefined = 194,
8490 String = 133,
8491 Number = 132,
8492 Boolean = 195,
8493 Symbol = 196,
8494 Bigint = 197,
8495 }; // enum class Type
8496
8497 // Named after property name 'subtype' while generating ObjectPreview.
8498 enum class Subtype {
8499 Array = 134,
8500 Null = 135,
8501 Node = 198,
8502 Regexp = 199,
8503 Date = 107,
8504 Error = 77,
8505 Map = 200,
8506 Set = 201,
8507 Weakmap = 202,
8508 Weakset = 203,
8509 Iterator = 204,
8510 Class = 205,
8511 Proxy = 206,
8512 }; // enum class Subtype
8513
8514 enum {
8515 NoFieldsSet = 0,
8516 TypeSet = 1 << 0,
8517 LosslessSet = 1 << 1,
8518 AllFieldsSet = (TypeSet | LosslessSet)
8519 };
8520
8521 template<int STATE>
8522 class Builder {
8523 private:
8524 RefPtr<JSON::Object> m_result;
8525
8526 template<int STEP> Builder<STATE | STEP>& castState()
8527 {
8528 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8529 }
8530
8531 Builder(Ref</*ObjectPreview*/JSON::Object>&& object)
8532 : m_result(WTFMove(object))
8533 {
8534 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8535 }
8536 friend class ObjectPreview;
8537 public:
8538
8539 Builder<STATE | TypeSet>& setType(Type in_type)
8540 {
8541 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
8542 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
8543 return castState<TypeSet>();
8544 }
8545
8546 Builder<STATE | LosslessSet>& setLossless(bool in_lossless)
8547 {
8548 COMPILE_ASSERT(!(STATE & LosslessSet), property_lossless_already_set);
8549 m_result->setBoolean("lossless"_s, in_lossless);
8550 return castState<LosslessSet>();
8551 }
8552
8553 Ref<ObjectPreview> release()
8554 {
8555 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8556 COMPILE_ASSERT(sizeof(ObjectPreview) == sizeof(JSON::Object), cannot_cast);
8557
8558 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8559 auto result = WTFMove(*reinterpret_cast<Ref<ObjectPreview>*>(&jsonResult));
8560 return result;
8561 }
8562 };
8563
8564 /*
8565 * Synthetic constructor:
8566 * Ref<ObjectPreview> result = ObjectPreview::create()
8567 * .setType(...)
8568 * .setLossless(...)
8569 * .release();
8570 */
8571 static Builder<NoFieldsSet> create()
8572 {
8573 return Builder<NoFieldsSet>(JSON::Object::create());
8574 }
8575
8576 void setSubtype(Subtype in_opt_subtype)
8577 {
8578 JSON::ObjectBase::setString("subtype"_s, Protocol::Helpers::getEnumConstantValue(in_opt_subtype));
8579 }
8580
8581 void setDescription(const String& in_opt_description)
8582 {
8583 JSON::ObjectBase::setString("description"_s, in_opt_description);
8584 }
8585
8586 void setOverflow(bool in_opt_overflow)
8587 {
8588 JSON::ObjectBase::setBoolean("overflow"_s, in_opt_overflow);
8589 }
8590
8591 void setProperties(Ref<JSON::ArrayOf<Protocol::Runtime::PropertyPreview>>&& in_opt_properties)
8592 {
8593 JSON::ObjectBase::setArray("properties"_s, WTFMove(in_opt_properties));
8594 }
8595
8596 void setEntries(Ref<JSON::ArrayOf<Protocol::Runtime::EntryPreview>>&& in_opt_entries)
8597 {
8598 JSON::ObjectBase::setArray("entries"_s, WTFMove(in_opt_entries));
8599 }
8600
8601 void setSize(int in_opt_size)
8602 {
8603 JSON::ObjectBase::setInteger("size"_s, in_opt_size);
8604 }
8605};
8606
8607class PropertyPreview final : public JSON::ObjectBase {
8608public:
8609 // Named after property name 'type' while generating PropertyPreview.
8610 enum class Type {
8611 Object = 192,
8612 Function = 193,
8613 Undefined = 194,
8614 String = 133,
8615 Number = 132,
8616 Boolean = 195,
8617 Symbol = 196,
8618 Bigint = 197,
8619 Accessor = 207,
8620 }; // enum class Type
8621
8622 // Named after property name 'subtype' while generating PropertyPreview.
8623 enum class Subtype {
8624 Array = 134,
8625 Null = 135,
8626 Node = 198,
8627 Regexp = 199,
8628 Date = 107,
8629 Error = 77,
8630 Map = 200,
8631 Set = 201,
8632 Weakmap = 202,
8633 Weakset = 203,
8634 Iterator = 204,
8635 Class = 205,
8636 Proxy = 206,
8637 }; // enum class Subtype
8638
8639 enum {
8640 NoFieldsSet = 0,
8641 NameSet = 1 << 0,
8642 TypeSet = 1 << 1,
8643 AllFieldsSet = (NameSet | TypeSet)
8644 };
8645
8646 template<int STATE>
8647 class Builder {
8648 private:
8649 RefPtr<JSON::Object> m_result;
8650
8651 template<int STEP> Builder<STATE | STEP>& castState()
8652 {
8653 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8654 }
8655
8656 Builder(Ref</*PropertyPreview*/JSON::Object>&& object)
8657 : m_result(WTFMove(object))
8658 {
8659 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8660 }
8661 friend class PropertyPreview;
8662 public:
8663
8664 Builder<STATE | NameSet>& setName(const String& in_name)
8665 {
8666 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8667 m_result->setString("name"_s, in_name);
8668 return castState<NameSet>();
8669 }
8670
8671 Builder<STATE | TypeSet>& setType(Type in_type)
8672 {
8673 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
8674 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
8675 return castState<TypeSet>();
8676 }
8677
8678 Ref<PropertyPreview> release()
8679 {
8680 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8681 COMPILE_ASSERT(sizeof(PropertyPreview) == sizeof(JSON::Object), cannot_cast);
8682
8683 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8684 auto result = WTFMove(*reinterpret_cast<Ref<PropertyPreview>*>(&jsonResult));
8685 return result;
8686 }
8687 };
8688
8689 /*
8690 * Synthetic constructor:
8691 * Ref<PropertyPreview> result = PropertyPreview::create()
8692 * .setName(...)
8693 * .setType(...)
8694 * .release();
8695 */
8696 static Builder<NoFieldsSet> create()
8697 {
8698 return Builder<NoFieldsSet>(JSON::Object::create());
8699 }
8700
8701 void setSubtype(Subtype in_opt_subtype)
8702 {
8703 JSON::ObjectBase::setString("subtype"_s, Protocol::Helpers::getEnumConstantValue(in_opt_subtype));
8704 }
8705
8706 void setValue(const String& in_opt_value)
8707 {
8708 JSON::ObjectBase::setString("value"_s, in_opt_value);
8709 }
8710
8711 void setValuePreview(Ref<Protocol::Runtime::ObjectPreview>&& in_opt_valuePreview)
8712 {
8713 JSON::ObjectBase::setObject("valuePreview"_s, WTFMove(in_opt_valuePreview));
8714 }
8715
8716 void setInternal(bool in_opt_internal)
8717 {
8718 JSON::ObjectBase::setBoolean("internal"_s, in_opt_internal);
8719 }
8720};
8721
8722class EntryPreview final : public JSON::ObjectBase {
8723public:
8724 enum {
8725 NoFieldsSet = 0,
8726 ValueSet = 1 << 0,
8727 AllFieldsSet = (ValueSet)
8728 };
8729
8730 template<int STATE>
8731 class Builder {
8732 private:
8733 RefPtr<JSON::Object> m_result;
8734
8735 template<int STEP> Builder<STATE | STEP>& castState()
8736 {
8737 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8738 }
8739
8740 Builder(Ref</*EntryPreview*/JSON::Object>&& object)
8741 : m_result(WTFMove(object))
8742 {
8743 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8744 }
8745 friend class EntryPreview;
8746 public:
8747
8748 Builder<STATE | ValueSet>& setValue(Ref<Protocol::Runtime::ObjectPreview>&& in_value)
8749 {
8750 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
8751 m_result->setObject("value"_s, WTFMove(in_value));
8752 return castState<ValueSet>();
8753 }
8754
8755 Ref<EntryPreview> release()
8756 {
8757 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8758 COMPILE_ASSERT(sizeof(EntryPreview) == sizeof(JSON::Object), cannot_cast);
8759
8760 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8761 auto result = WTFMove(*reinterpret_cast<Ref<EntryPreview>*>(&jsonResult));
8762 return result;
8763 }
8764 };
8765
8766 /*
8767 * Synthetic constructor:
8768 * Ref<EntryPreview> result = EntryPreview::create()
8769 * .setValue(...)
8770 * .release();
8771 */
8772 static Builder<NoFieldsSet> create()
8773 {
8774 return Builder<NoFieldsSet>(JSON::Object::create());
8775 }
8776
8777 void setKey(Ref<Protocol::Runtime::ObjectPreview>&& in_opt_key)
8778 {
8779 JSON::ObjectBase::setObject("key"_s, WTFMove(in_opt_key));
8780 }
8781};
8782
8783class CollectionEntry final : public JSON::ObjectBase {
8784public:
8785 enum {
8786 NoFieldsSet = 0,
8787 ValueSet = 1 << 0,
8788 AllFieldsSet = (ValueSet)
8789 };
8790
8791 template<int STATE>
8792 class Builder {
8793 private:
8794 RefPtr<JSON::Object> m_result;
8795
8796 template<int STEP> Builder<STATE | STEP>& castState()
8797 {
8798 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8799 }
8800
8801 Builder(Ref</*CollectionEntry*/JSON::Object>&& object)
8802 : m_result(WTFMove(object))
8803 {
8804 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8805 }
8806 friend class CollectionEntry;
8807 public:
8808
8809 Builder<STATE | ValueSet>& setValue(Ref<Protocol::Runtime::RemoteObject>&& in_value)
8810 {
8811 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
8812 m_result->setObject("value"_s, WTFMove(in_value));
8813 return castState<ValueSet>();
8814 }
8815
8816 Ref<CollectionEntry> release()
8817 {
8818 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8819 COMPILE_ASSERT(sizeof(CollectionEntry) == sizeof(JSON::Object), cannot_cast);
8820
8821 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8822 auto result = WTFMove(*reinterpret_cast<Ref<CollectionEntry>*>(&jsonResult));
8823 return result;
8824 }
8825 };
8826
8827 /*
8828 * Synthetic constructor:
8829 * Ref<CollectionEntry> result = CollectionEntry::create()
8830 * .setValue(...)
8831 * .release();
8832 */
8833 static Builder<NoFieldsSet> create()
8834 {
8835 return Builder<NoFieldsSet>(JSON::Object::create());
8836 }
8837
8838 void setKey(Ref<Protocol::Runtime::RemoteObject>&& in_opt_key)
8839 {
8840 JSON::ObjectBase::setObject("key"_s, WTFMove(in_opt_key));
8841 }
8842};
8843
8844/* Object property descriptor. */
8845class PropertyDescriptor final : public JSON::ObjectBase {
8846public:
8847 enum {
8848 NoFieldsSet = 0,
8849 NameSet = 1 << 0,
8850 AllFieldsSet = (NameSet)
8851 };
8852
8853 template<int STATE>
8854 class Builder {
8855 private:
8856 RefPtr<JSON::Object> m_result;
8857
8858 template<int STEP> Builder<STATE | STEP>& castState()
8859 {
8860 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8861 }
8862
8863 Builder(Ref</*PropertyDescriptor*/JSON::Object>&& object)
8864 : m_result(WTFMove(object))
8865 {
8866 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8867 }
8868 friend class PropertyDescriptor;
8869 public:
8870
8871 Builder<STATE | NameSet>& setName(const String& in_name)
8872 {
8873 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8874 m_result->setString("name"_s, in_name);
8875 return castState<NameSet>();
8876 }
8877
8878 Ref<PropertyDescriptor> release()
8879 {
8880 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8881 COMPILE_ASSERT(sizeof(PropertyDescriptor) == sizeof(JSON::Object), cannot_cast);
8882
8883 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8884 auto result = WTFMove(*reinterpret_cast<Ref<PropertyDescriptor>*>(&jsonResult));
8885 return result;
8886 }
8887 };
8888
8889 /*
8890 * Synthetic constructor:
8891 * Ref<PropertyDescriptor> result = PropertyDescriptor::create()
8892 * .setName(...)
8893 * .release();
8894 */
8895 static Builder<NoFieldsSet> create()
8896 {
8897 return Builder<NoFieldsSet>(JSON::Object::create());
8898 }
8899
8900 void setValue(Ref<Protocol::Runtime::RemoteObject>&& in_opt_value)
8901 {
8902 JSON::ObjectBase::setObject("value"_s, WTFMove(in_opt_value));
8903 }
8904
8905 void setWritable(bool in_opt_writable)
8906 {
8907 JSON::ObjectBase::setBoolean("writable"_s, in_opt_writable);
8908 }
8909
8910 void setGet(Ref<Protocol::Runtime::RemoteObject>&& in_opt_get)
8911 {
8912 JSON::ObjectBase::setObject("get"_s, WTFMove(in_opt_get));
8913 }
8914
8915 void setSet(Ref<Protocol::Runtime::RemoteObject>&& in_opt_set)
8916 {
8917 JSON::ObjectBase::setObject("set"_s, WTFMove(in_opt_set));
8918 }
8919
8920 void setWasThrown(bool in_opt_wasThrown)
8921 {
8922 JSON::ObjectBase::setBoolean("wasThrown"_s, in_opt_wasThrown);
8923 }
8924
8925 void setConfigurable(bool in_opt_configurable)
8926 {
8927 JSON::ObjectBase::setBoolean("configurable"_s, in_opt_configurable);
8928 }
8929
8930 void setEnumerable(bool in_opt_enumerable)
8931 {
8932 JSON::ObjectBase::setBoolean("enumerable"_s, in_opt_enumerable);
8933 }
8934
8935 void setIsOwn(bool in_opt_isOwn)
8936 {
8937 JSON::ObjectBase::setBoolean("isOwn"_s, in_opt_isOwn);
8938 }
8939
8940 void setSymbol(Ref<Protocol::Runtime::RemoteObject>&& in_opt_symbol)
8941 {
8942 JSON::ObjectBase::setObject("symbol"_s, WTFMove(in_opt_symbol));
8943 }
8944
8945 void setNativeGetter(bool in_opt_nativeGetter)
8946 {
8947 JSON::ObjectBase::setBoolean("nativeGetter"_s, in_opt_nativeGetter);
8948 }
8949};
8950
8951/* Object internal property descriptor. This property isn't normally visible in JavaScript code. */
8952class InternalPropertyDescriptor final : public JSON::ObjectBase {
8953public:
8954 enum {
8955 NoFieldsSet = 0,
8956 NameSet = 1 << 0,
8957 AllFieldsSet = (NameSet)
8958 };
8959
8960 template<int STATE>
8961 class Builder {
8962 private:
8963 RefPtr<JSON::Object> m_result;
8964
8965 template<int STEP> Builder<STATE | STEP>& castState()
8966 {
8967 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8968 }
8969
8970 Builder(Ref</*InternalPropertyDescriptor*/JSON::Object>&& object)
8971 : m_result(WTFMove(object))
8972 {
8973 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8974 }
8975 friend class InternalPropertyDescriptor;
8976 public:
8977
8978 Builder<STATE | NameSet>& setName(const String& in_name)
8979 {
8980 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8981 m_result->setString("name"_s, in_name);
8982 return castState<NameSet>();
8983 }
8984
8985 Ref<InternalPropertyDescriptor> release()
8986 {
8987 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8988 COMPILE_ASSERT(sizeof(InternalPropertyDescriptor) == sizeof(JSON::Object), cannot_cast);
8989
8990 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8991 auto result = WTFMove(*reinterpret_cast<Ref<InternalPropertyDescriptor>*>(&jsonResult));
8992 return result;
8993 }
8994 };
8995
8996 /*
8997 * Synthetic constructor:
8998 * Ref<InternalPropertyDescriptor> result = InternalPropertyDescriptor::create()
8999 * .setName(...)
9000 * .release();
9001 */
9002 static Builder<NoFieldsSet> create()
9003 {
9004 return Builder<NoFieldsSet>(JSON::Object::create());
9005 }
9006
9007 void setValue(Ref<Protocol::Runtime::RemoteObject>&& in_opt_value)
9008 {
9009 JSON::ObjectBase::setObject("value"_s, WTFMove(in_opt_value));
9010 }
9011};
9012
9013/* Represents function call argument. Either remote object id <code>objectId</code> or primitive <code>value</code> or neither of (for undefined) them should be specified. */
9014class CallArgument final : public JSON::Object {
9015public:
9016 enum {
9017 NoFieldsSet = 0,
9018 AllFieldsSet = 0
9019 };
9020
9021 template<int STATE>
9022 class Builder {
9023 private:
9024 RefPtr<JSON::Object> m_result;
9025
9026 template<int STEP> Builder<STATE | STEP>& castState()
9027 {
9028 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9029 }
9030
9031 Builder(Ref</*CallArgument*/JSON::Object>&& object)
9032 : m_result(WTFMove(object))
9033 {
9034 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9035 }
9036 friend class CallArgument;
9037 public:
9038
9039 Ref<CallArgument> release()
9040 {
9041 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9042 COMPILE_ASSERT(sizeof(CallArgument) == sizeof(JSON::Object), cannot_cast);
9043
9044 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9045 auto result = WTFMove(*reinterpret_cast<Ref<CallArgument>*>(&jsonResult));
9046 return result;
9047 }
9048 };
9049
9050 /*
9051 * Synthetic constructor:
9052 * Ref<CallArgument> result = CallArgument::create()
9053 * .release();
9054 */
9055 static Builder<NoFieldsSet> create()
9056 {
9057 return Builder<NoFieldsSet>(JSON::Object::create());
9058 }
9059
9060 void setValue(Ref<JSON::Value>&& in_opt_value)
9061 {
9062 JSON::ObjectBase::setValue("value"_s, WTFMove(in_opt_value));
9063 }
9064
9065 void setObjectId(const String& in_opt_objectId)
9066 {
9067 JSON::ObjectBase::setString("objectId"_s, in_opt_objectId);
9068 }
9069
9070 // Property names for type generated as open.
9071 JS_EXPORT_PRIVATE static const ASCIILiteral objectIdKey;
9072};
9073
9074/* Type of the execution context. */
9075enum class ExecutionContextType {
9076 Normal = 5,
9077 User = 16,
9078 Internal = 208,
9079}; // enum class ExecutionContextType
9080
9081/* Description of an isolated world. */
9082class ExecutionContextDescription final : public JSON::ObjectBase {
9083public:
9084 enum {
9085 NoFieldsSet = 0,
9086 IdSet = 1 << 0,
9087 TypeSet = 1 << 1,
9088 NameSet = 1 << 2,
9089 FrameIdSet = 1 << 3,
9090 AllFieldsSet = (IdSet | TypeSet | NameSet | FrameIdSet)
9091 };
9092
9093 template<int STATE>
9094 class Builder {
9095 private:
9096 RefPtr<JSON::Object> m_result;
9097
9098 template<int STEP> Builder<STATE | STEP>& castState()
9099 {
9100 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9101 }
9102
9103 Builder(Ref</*ExecutionContextDescription*/JSON::Object>&& object)
9104 : m_result(WTFMove(object))
9105 {
9106 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9107 }
9108 friend class ExecutionContextDescription;
9109 public:
9110
9111 Builder<STATE | IdSet>& setId(int in_id)
9112 {
9113 COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
9114 m_result->setInteger("id"_s, in_id);
9115 return castState<IdSet>();
9116 }
9117
9118 Builder<STATE | TypeSet>& setType(Protocol::Runtime::ExecutionContextType in_type)
9119 {
9120 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
9121 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
9122 return castState<TypeSet>();
9123 }
9124
9125 Builder<STATE | NameSet>& setName(const String& in_name)
9126 {
9127 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
9128 m_result->setString("name"_s, in_name);
9129 return castState<NameSet>();
9130 }
9131
9132 Builder<STATE | FrameIdSet>& setFrameId(const String& in_frameId)
9133 {
9134 COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
9135 m_result->setString("frameId"_s, in_frameId);
9136 return castState<FrameIdSet>();
9137 }
9138
9139 Ref<ExecutionContextDescription> release()
9140 {
9141 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9142 COMPILE_ASSERT(sizeof(ExecutionContextDescription) == sizeof(JSON::Object), cannot_cast);
9143
9144 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9145 auto result = WTFMove(*reinterpret_cast<Ref<ExecutionContextDescription>*>(&jsonResult));
9146 return result;
9147 }
9148 };
9149
9150 /*
9151 * Synthetic constructor:
9152 * Ref<ExecutionContextDescription> result = ExecutionContextDescription::create()
9153 * .setId(...)
9154 * .setType(...)
9155 * .setName(...)
9156 * .setFrameId(...)
9157 * .release();
9158 */
9159 static Builder<NoFieldsSet> create()
9160 {
9161 return Builder<NoFieldsSet>(JSON::Object::create());
9162 }
9163};
9164
9165/* Syntax error type: "none" for no error, "irrecoverable" for unrecoverable errors, "unterminated-literal" for when there is an unterminated literal, "recoverable" for when the expression is unfinished but valid so far. */
9166enum class SyntaxErrorType {
9167 None = 9,
9168 Irrecoverable = 209,
9169 UnterminatedLiteral = 210,
9170 Recoverable = 211,
9171}; // enum class SyntaxErrorType
9172
9173/* Range of an error in source code. */
9174class ErrorRange final : public JSON::ObjectBase {
9175public:
9176 enum {
9177 NoFieldsSet = 0,
9178 StartOffsetSet = 1 << 0,
9179 EndOffsetSet = 1 << 1,
9180 AllFieldsSet = (StartOffsetSet | EndOffsetSet)
9181 };
9182
9183 template<int STATE>
9184 class Builder {
9185 private:
9186 RefPtr<JSON::Object> m_result;
9187
9188 template<int STEP> Builder<STATE | STEP>& castState()
9189 {
9190 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9191 }
9192
9193 Builder(Ref</*ErrorRange*/JSON::Object>&& object)
9194 : m_result(WTFMove(object))
9195 {
9196 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9197 }
9198 friend class ErrorRange;
9199 public:
9200
9201 Builder<STATE | StartOffsetSet>& setStartOffset(int in_startOffset)
9202 {
9203 COMPILE_ASSERT(!(STATE & StartOffsetSet), property_startOffset_already_set);
9204 m_result->setInteger("startOffset"_s, in_startOffset);
9205 return castState<StartOffsetSet>();
9206 }
9207
9208 Builder<STATE | EndOffsetSet>& setEndOffset(int in_endOffset)
9209 {
9210 COMPILE_ASSERT(!(STATE & EndOffsetSet), property_endOffset_already_set);
9211 m_result->setInteger("endOffset"_s, in_endOffset);
9212 return castState<EndOffsetSet>();
9213 }
9214
9215 Ref<ErrorRange> release()
9216 {
9217 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9218 COMPILE_ASSERT(sizeof(ErrorRange) == sizeof(JSON::Object), cannot_cast);
9219
9220 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9221 auto result = WTFMove(*reinterpret_cast<Ref<ErrorRange>*>(&jsonResult));
9222 return result;
9223 }
9224 };
9225
9226 /*
9227 * Synthetic constructor:
9228 * Ref<ErrorRange> result = ErrorRange::create()
9229 * .setStartOffset(...)
9230 * .setEndOffset(...)
9231 * .release();
9232 */
9233 static Builder<NoFieldsSet> create()
9234 {
9235 return Builder<NoFieldsSet>(JSON::Object::create());
9236 }
9237};
9238
9239class StructureDescription final : public JSON::ObjectBase {
9240public:
9241 enum {
9242 NoFieldsSet = 0,
9243 AllFieldsSet = 0
9244 };
9245
9246 template<int STATE>
9247 class Builder {
9248 private:
9249 RefPtr<JSON::Object> m_result;
9250
9251 template<int STEP> Builder<STATE | STEP>& castState()
9252 {
9253 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9254 }
9255
9256 Builder(Ref</*StructureDescription*/JSON::Object>&& object)
9257 : m_result(WTFMove(object))
9258 {
9259 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9260 }
9261 friend class StructureDescription;
9262 public:
9263
9264 Ref<StructureDescription> release()
9265 {
9266 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9267 COMPILE_ASSERT(sizeof(StructureDescription) == sizeof(JSON::Object), cannot_cast);
9268
9269 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9270 auto result = WTFMove(*reinterpret_cast<Ref<StructureDescription>*>(&jsonResult));
9271 return result;
9272 }
9273 };
9274
9275 /*
9276 * Synthetic constructor:
9277 * Ref<StructureDescription> result = StructureDescription::create()
9278 * .release();
9279 */
9280 static Builder<NoFieldsSet> create()
9281 {
9282 return Builder<NoFieldsSet>(JSON::Object::create());
9283 }
9284
9285 void setFields(Ref<JSON::ArrayOf<String>>&& in_opt_fields)
9286 {
9287 JSON::ObjectBase::setArray("fields"_s, WTFMove(in_opt_fields));
9288 }
9289
9290 void setOptionalFields(Ref<JSON::ArrayOf<String>>&& in_opt_optionalFields)
9291 {
9292 JSON::ObjectBase::setArray("optionalFields"_s, WTFMove(in_opt_optionalFields));
9293 }
9294
9295 void setConstructorName(const String& in_opt_constructorName)
9296 {
9297 JSON::ObjectBase::setString("constructorName"_s, in_opt_constructorName);
9298 }
9299
9300 void setPrototypeStructure(Ref<Protocol::Runtime::StructureDescription>&& in_opt_prototypeStructure)
9301 {
9302 JSON::ObjectBase::setObject("prototypeStructure"_s, WTFMove(in_opt_prototypeStructure));
9303 }
9304
9305 void setIsImprecise(bool in_opt_isImprecise)
9306 {
9307 JSON::ObjectBase::setBoolean("isImprecise"_s, in_opt_isImprecise);
9308 }
9309};
9310
9311class TypeSet final : public JSON::ObjectBase {
9312public:
9313 enum {
9314 NoFieldsSet = 0,
9315 IsFunctionSet = 1 << 0,
9316 IsUndefinedSet = 1 << 1,
9317 IsNullSet = 1 << 2,
9318 IsBooleanSet = 1 << 3,
9319 IsIntegerSet = 1 << 4,
9320 IsNumberSet = 1 << 5,
9321 IsStringSet = 1 << 6,
9322 IsObjectSet = 1 << 7,
9323 IsSymbolSet = 1 << 8,
9324 IsBigIntSet = 1 << 9,
9325 AllFieldsSet = (IsFunctionSet | IsUndefinedSet | IsNullSet | IsBooleanSet | IsIntegerSet | IsNumberSet | IsStringSet | IsObjectSet | IsSymbolSet | IsBigIntSet)
9326 };
9327
9328 template<int STATE>
9329 class Builder {
9330 private:
9331 RefPtr<JSON::Object> m_result;
9332
9333 template<int STEP> Builder<STATE | STEP>& castState()
9334 {
9335 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9336 }
9337
9338 Builder(Ref</*TypeSet*/JSON::Object>&& object)
9339 : m_result(WTFMove(object))
9340 {
9341 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9342 }
9343 friend class TypeSet;
9344 public:
9345
9346 Builder<STATE | IsFunctionSet>& setIsFunction(bool in_isFunction)
9347 {
9348 COMPILE_ASSERT(!(STATE & IsFunctionSet), property_isFunction_already_set);
9349 m_result->setBoolean("isFunction"_s, in_isFunction);
9350 return castState<IsFunctionSet>();
9351 }
9352
9353 Builder<STATE | IsUndefinedSet>& setIsUndefined(bool in_isUndefined)
9354 {
9355 COMPILE_ASSERT(!(STATE & IsUndefinedSet), property_isUndefined_already_set);
9356 m_result->setBoolean("isUndefined"_s, in_isUndefined);
9357 return castState<IsUndefinedSet>();
9358 }
9359
9360 Builder<STATE | IsNullSet>& setIsNull(bool in_isNull)
9361 {
9362 COMPILE_ASSERT(!(STATE & IsNullSet), property_isNull_already_set);
9363 m_result->setBoolean("isNull"_s, in_isNull);
9364 return castState<IsNullSet>();
9365 }
9366
9367 Builder<STATE | IsBooleanSet>& setIsBoolean(bool in_isBoolean)
9368 {
9369 COMPILE_ASSERT(!(STATE & IsBooleanSet), property_isBoolean_already_set);
9370 m_result->setBoolean("isBoolean"_s, in_isBoolean);
9371 return castState<IsBooleanSet>();
9372 }
9373
9374 Builder<STATE | IsIntegerSet>& setIsInteger(bool in_isInteger)
9375 {
9376 COMPILE_ASSERT(!(STATE & IsIntegerSet), property_isInteger_already_set);
9377 m_result->setBoolean("isInteger"_s, in_isInteger);
9378 return castState<IsIntegerSet>();
9379 }
9380
9381 Builder<STATE | IsNumberSet>& setIsNumber(bool in_isNumber)
9382 {
9383 COMPILE_ASSERT(!(STATE & IsNumberSet), property_isNumber_already_set);
9384 m_result->setBoolean("isNumber"_s, in_isNumber);
9385 return castState<IsNumberSet>();
9386 }
9387
9388 Builder<STATE | IsStringSet>& setIsString(bool in_isString)
9389 {
9390 COMPILE_ASSERT(!(STATE & IsStringSet), property_isString_already_set);
9391 m_result->setBoolean("isString"_s, in_isString);
9392 return castState<IsStringSet>();
9393 }
9394
9395 Builder<STATE | IsObjectSet>& setIsObject(bool in_isObject)
9396 {
9397 COMPILE_ASSERT(!(STATE & IsObjectSet), property_isObject_already_set);
9398 m_result->setBoolean("isObject"_s, in_isObject);
9399 return castState<IsObjectSet>();
9400 }
9401
9402 Builder<STATE | IsSymbolSet>& setIsSymbol(bool in_isSymbol)
9403 {
9404 COMPILE_ASSERT(!(STATE & IsSymbolSet), property_isSymbol_already_set);
9405 m_result->setBoolean("isSymbol"_s, in_isSymbol);
9406 return castState<IsSymbolSet>();
9407 }
9408
9409 Builder<STATE | IsBigIntSet>& setIsBigInt(bool in_isBigInt)
9410 {
9411 COMPILE_ASSERT(!(STATE & IsBigIntSet), property_isBigInt_already_set);
9412 m_result->setBoolean("isBigInt"_s, in_isBigInt);
9413 return castState<IsBigIntSet>();
9414 }
9415
9416 Ref<TypeSet> release()
9417 {
9418 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9419 COMPILE_ASSERT(sizeof(TypeSet) == sizeof(JSON::Object), cannot_cast);
9420
9421 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9422 auto result = WTFMove(*reinterpret_cast<Ref<TypeSet>*>(&jsonResult));
9423 return result;
9424 }
9425 };
9426
9427 /*
9428 * Synthetic constructor:
9429 * Ref<TypeSet> result = TypeSet::create()
9430 * .setIsFunction(...)
9431 * .setIsUndefined(...)
9432 * .setIsNull(...)
9433 * .setIsBoolean(...)
9434 * .setIsInteger(...)
9435 * .setIsNumber(...)
9436 * .setIsString(...)
9437 * .setIsObject(...)
9438 * .setIsSymbol(...)
9439 * .setIsBigInt(...)
9440 * .release();
9441 */
9442 static Builder<NoFieldsSet> create()
9443 {
9444 return Builder<NoFieldsSet>(JSON::Object::create());
9445 }
9446};
9447
9448/* Container for type information that has been gathered. */
9449class TypeDescription final : public JSON::ObjectBase {
9450public:
9451 enum {
9452 NoFieldsSet = 0,
9453 IsValidSet = 1 << 0,
9454 AllFieldsSet = (IsValidSet)
9455 };
9456
9457 template<int STATE>
9458 class Builder {
9459 private:
9460 RefPtr<JSON::Object> m_result;
9461
9462 template<int STEP> Builder<STATE | STEP>& castState()
9463 {
9464 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9465 }
9466
9467 Builder(Ref</*TypeDescription*/JSON::Object>&& object)
9468 : m_result(WTFMove(object))
9469 {
9470 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9471 }
9472 friend class TypeDescription;
9473 public:
9474
9475 Builder<STATE | IsValidSet>& setIsValid(bool in_isValid)
9476 {
9477 COMPILE_ASSERT(!(STATE & IsValidSet), property_isValid_already_set);
9478 m_result->setBoolean("isValid"_s, in_isValid);
9479 return castState<IsValidSet>();
9480 }
9481
9482 Ref<TypeDescription> release()
9483 {
9484 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9485 COMPILE_ASSERT(sizeof(TypeDescription) == sizeof(JSON::Object), cannot_cast);
9486
9487 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9488 auto result = WTFMove(*reinterpret_cast<Ref<TypeDescription>*>(&jsonResult));
9489 return result;
9490 }
9491 };
9492
9493 /*
9494 * Synthetic constructor:
9495 * Ref<TypeDescription> result = TypeDescription::create()
9496 * .setIsValid(...)
9497 * .release();
9498 */
9499 static Builder<NoFieldsSet> create()
9500 {
9501 return Builder<NoFieldsSet>(JSON::Object::create());
9502 }
9503
9504 void setLeastCommonAncestor(const String& in_opt_leastCommonAncestor)
9505 {
9506 JSON::ObjectBase::setString("leastCommonAncestor"_s, in_opt_leastCommonAncestor);
9507 }
9508
9509 void setTypeSet(Ref<Protocol::Runtime::TypeSet>&& in_opt_typeSet)
9510 {
9511 JSON::ObjectBase::setObject("typeSet"_s, WTFMove(in_opt_typeSet));
9512 }
9513
9514 void setStructures(Ref<JSON::ArrayOf<Protocol::Runtime::StructureDescription>>&& in_opt_structures)
9515 {
9516 JSON::ObjectBase::setArray("structures"_s, WTFMove(in_opt_structures));
9517 }
9518
9519 void setIsTruncated(bool in_opt_isTruncated)
9520 {
9521 JSON::ObjectBase::setBoolean("isTruncated"_s, in_opt_isTruncated);
9522 }
9523};
9524
9525/* Describes the location of an expression we want type information for. */
9526class TypeLocation final : public JSON::Object {
9527public:
9528 enum {
9529 NoFieldsSet = 0,
9530 TypeInformationDescriptorSet = 1 << 0,
9531 SourceIDSet = 1 << 1,
9532 DivotSet = 1 << 2,
9533 AllFieldsSet = (TypeInformationDescriptorSet | SourceIDSet | DivotSet)
9534 };
9535
9536 template<int STATE>
9537 class Builder {
9538 private:
9539 RefPtr<JSON::Object> m_result;
9540
9541 template<int STEP> Builder<STATE | STEP>& castState()
9542 {
9543 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9544 }
9545
9546 Builder(Ref</*TypeLocation*/JSON::Object>&& object)
9547 : m_result(WTFMove(object))
9548 {
9549 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9550 }
9551 friend class TypeLocation;
9552 public:
9553
9554 Builder<STATE | TypeInformationDescriptorSet>& setTypeInformationDescriptor(int in_typeInformationDescriptor)
9555 {
9556 COMPILE_ASSERT(!(STATE & TypeInformationDescriptorSet), property_typeInformationDescriptor_already_set);
9557 m_result->setInteger("typeInformationDescriptor"_s, in_typeInformationDescriptor);
9558 return castState<TypeInformationDescriptorSet>();
9559 }
9560
9561 Builder<STATE | SourceIDSet>& setSourceID(const String& in_sourceID)
9562 {
9563 COMPILE_ASSERT(!(STATE & SourceIDSet), property_sourceID_already_set);
9564 m_result->setString("sourceID"_s, in_sourceID);
9565 return castState<SourceIDSet>();
9566 }
9567
9568 Builder<STATE | DivotSet>& setDivot(int in_divot)
9569 {
9570 COMPILE_ASSERT(!(STATE & DivotSet), property_divot_already_set);
9571 m_result->setInteger("divot"_s, in_divot);
9572 return castState<DivotSet>();
9573 }
9574
9575 Ref<TypeLocation> release()
9576 {
9577 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9578 COMPILE_ASSERT(sizeof(TypeLocation) == sizeof(JSON::Object), cannot_cast);
9579
9580 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9581 auto result = WTFMove(*reinterpret_cast<Ref<TypeLocation>*>(&jsonResult));
9582 return result;
9583 }
9584 };
9585
9586 /*
9587 * Synthetic constructor:
9588 * Ref<TypeLocation> result = TypeLocation::create()
9589 * .setTypeInformationDescriptor(...)
9590 * .setSourceID(...)
9591 * .setDivot(...)
9592 * .release();
9593 */
9594 static Builder<NoFieldsSet> create()
9595 {
9596 return Builder<NoFieldsSet>(JSON::Object::create());
9597 }
9598
9599 // Property names for type generated as open.
9600 JS_EXPORT_PRIVATE static const ASCIILiteral typeInformationDescriptorKey;
9601 JS_EXPORT_PRIVATE static const ASCIILiteral sourceIDKey;
9602 JS_EXPORT_PRIVATE static const ASCIILiteral divotKey;
9603};
9604
9605/* From Wikipedia: a basic block is a portion of the code within a program with only one entry point and only one exit point. This type gives the location of a basic block and if that basic block has executed. */
9606class BasicBlock final : public JSON::ObjectBase {
9607public:
9608 enum {
9609 NoFieldsSet = 0,
9610 StartOffsetSet = 1 << 0,
9611 EndOffsetSet = 1 << 1,
9612 HasExecutedSet = 1 << 2,
9613 ExecutionCountSet = 1 << 3,
9614 AllFieldsSet = (StartOffsetSet | EndOffsetSet | HasExecutedSet | ExecutionCountSet)
9615 };
9616
9617 template<int STATE>
9618 class Builder {
9619 private:
9620 RefPtr<JSON::Object> m_result;
9621
9622 template<int STEP> Builder<STATE | STEP>& castState()
9623 {
9624 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9625 }
9626
9627 Builder(Ref</*BasicBlock*/JSON::Object>&& object)
9628 : m_result(WTFMove(object))
9629 {
9630 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9631 }
9632 friend class BasicBlock;
9633 public:
9634
9635 Builder<STATE | StartOffsetSet>& setStartOffset(int in_startOffset)
9636 {
9637 COMPILE_ASSERT(!(STATE & StartOffsetSet), property_startOffset_already_set);
9638 m_result->setInteger("startOffset"_s, in_startOffset);
9639 return castState<StartOffsetSet>();
9640 }
9641
9642 Builder<STATE | EndOffsetSet>& setEndOffset(int in_endOffset)
9643 {
9644 COMPILE_ASSERT(!(STATE & EndOffsetSet), property_endOffset_already_set);
9645 m_result->setInteger("endOffset"_s, in_endOffset);
9646 return castState<EndOffsetSet>();
9647 }
9648
9649 Builder<STATE | HasExecutedSet>& setHasExecuted(bool in_hasExecuted)
9650 {
9651 COMPILE_ASSERT(!(STATE & HasExecutedSet), property_hasExecuted_already_set);
9652 m_result->setBoolean("hasExecuted"_s, in_hasExecuted);
9653 return castState<HasExecutedSet>();
9654 }
9655
9656 Builder<STATE | ExecutionCountSet>& setExecutionCount(int in_executionCount)
9657 {
9658 COMPILE_ASSERT(!(STATE & ExecutionCountSet), property_executionCount_already_set);
9659 m_result->setInteger("executionCount"_s, in_executionCount);
9660 return castState<ExecutionCountSet>();
9661 }
9662
9663 Ref<BasicBlock> release()
9664 {
9665 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9666 COMPILE_ASSERT(sizeof(BasicBlock) == sizeof(JSON::Object), cannot_cast);
9667
9668 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9669 auto result = WTFMove(*reinterpret_cast<Ref<BasicBlock>*>(&jsonResult));
9670 return result;
9671 }
9672 };
9673
9674 /*
9675 * Synthetic constructor:
9676 * Ref<BasicBlock> result = BasicBlock::create()
9677 * .setStartOffset(...)
9678 * .setEndOffset(...)
9679 * .setHasExecuted(...)
9680 * .setExecutionCount(...)
9681 * .release();
9682 */
9683 static Builder<NoFieldsSet> create()
9684 {
9685 return Builder<NoFieldsSet>(JSON::Object::create());
9686 }
9687};
9688
9689} // Runtime
9690
9691namespace ScriptProfiler {
9692
9693enum class EventType {
9694 API = 212,
9695 Microtask = 213,
9696 Other = 157,
9697}; // enum class EventType
9698
9699class Event final : public JSON::ObjectBase {
9700public:
9701 enum {
9702 NoFieldsSet = 0,
9703 StartTimeSet = 1 << 0,
9704 EndTimeSet = 1 << 1,
9705 TypeSet = 1 << 2,
9706 AllFieldsSet = (StartTimeSet | EndTimeSet | TypeSet)
9707 };
9708
9709 template<int STATE>
9710 class Builder {
9711 private:
9712 RefPtr<JSON::Object> m_result;
9713
9714 template<int STEP> Builder<STATE | STEP>& castState()
9715 {
9716 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9717 }
9718
9719 Builder(Ref</*Event*/JSON::Object>&& object)
9720 : m_result(WTFMove(object))
9721 {
9722 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9723 }
9724 friend class Event;
9725 public:
9726
9727 Builder<STATE | StartTimeSet>& setStartTime(double in_startTime)
9728 {
9729 COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
9730 m_result->setDouble("startTime"_s, in_startTime);
9731 return castState<StartTimeSet>();
9732 }
9733
9734 Builder<STATE | EndTimeSet>& setEndTime(double in_endTime)
9735 {
9736 COMPILE_ASSERT(!(STATE & EndTimeSet), property_endTime_already_set);
9737 m_result->setDouble("endTime"_s, in_endTime);
9738 return castState<EndTimeSet>();
9739 }
9740
9741 Builder<STATE | TypeSet>& setType(Protocol::ScriptProfiler::EventType in_type)
9742 {
9743 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
9744 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
9745 return castState<TypeSet>();
9746 }
9747
9748 Ref<Event> release()
9749 {
9750 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9751 COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast);
9752
9753 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9754 auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult));
9755 return result;
9756 }
9757 };
9758
9759 /*
9760 * Synthetic constructor:
9761 * Ref<Event> result = Event::create()
9762 * .setStartTime(...)
9763 * .setEndTime(...)
9764 * .setType(...)
9765 * .release();
9766 */
9767 static Builder<NoFieldsSet> create()
9768 {
9769 return Builder<NoFieldsSet>(JSON::Object::create());
9770 }
9771};
9772
9773class ExpressionLocation final : public JSON::ObjectBase {
9774public:
9775 enum {
9776 NoFieldsSet = 0,
9777 LineSet = 1 << 0,
9778 ColumnSet = 1 << 1,
9779 AllFieldsSet = (LineSet | ColumnSet)
9780 };
9781
9782 template<int STATE>
9783 class Builder {
9784 private:
9785 RefPtr<JSON::Object> m_result;
9786
9787 template<int STEP> Builder<STATE | STEP>& castState()
9788 {
9789 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9790 }
9791
9792 Builder(Ref</*ExpressionLocation*/JSON::Object>&& object)
9793 : m_result(WTFMove(object))
9794 {
9795 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9796 }
9797 friend class ExpressionLocation;
9798 public:
9799
9800 Builder<STATE | LineSet>& setLine(int in_line)
9801 {
9802 COMPILE_ASSERT(!(STATE & LineSet), property_line_already_set);
9803 m_result->setInteger("line"_s, in_line);
9804 return castState<LineSet>();
9805 }
9806
9807 Builder<STATE | ColumnSet>& setColumn(int in_column)
9808 {
9809 COMPILE_ASSERT(!(STATE & ColumnSet), property_column_already_set);
9810 m_result->setInteger("column"_s, in_column);
9811 return castState<ColumnSet>();
9812 }
9813
9814 Ref<ExpressionLocation> release()
9815 {
9816 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9817 COMPILE_ASSERT(sizeof(ExpressionLocation) == sizeof(JSON::Object), cannot_cast);
9818
9819 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9820 auto result = WTFMove(*reinterpret_cast<Ref<ExpressionLocation>*>(&jsonResult));
9821 return result;
9822 }
9823 };
9824
9825 /*
9826 * Synthetic constructor:
9827 * Ref<ExpressionLocation> result = ExpressionLocation::create()
9828 * .setLine(...)
9829 * .setColumn(...)
9830 * .release();
9831 */
9832 static Builder<NoFieldsSet> create()
9833 {
9834 return Builder<NoFieldsSet>(JSON::Object::create());
9835 }
9836};
9837
9838class StackFrame final : public JSON::ObjectBase {
9839public:
9840 enum {
9841 NoFieldsSet = 0,
9842 SourceIDSet = 1 << 0,
9843 NameSet = 1 << 1,
9844 LineSet = 1 << 2,
9845 ColumnSet = 1 << 3,
9846 UrlSet = 1 << 4,
9847 AllFieldsSet = (SourceIDSet | NameSet | LineSet | ColumnSet | UrlSet)
9848 };
9849
9850 template<int STATE>
9851 class Builder {
9852 private:
9853 RefPtr<JSON::Object> m_result;
9854
9855 template<int STEP> Builder<STATE | STEP>& castState()
9856 {
9857 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9858 }
9859
9860 Builder(Ref</*StackFrame*/JSON::Object>&& object)
9861 : m_result(WTFMove(object))
9862 {
9863 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9864 }
9865 friend class StackFrame;
9866 public:
9867
9868 Builder<STATE | SourceIDSet>& setSourceID(const String& in_sourceID)
9869 {
9870 COMPILE_ASSERT(!(STATE & SourceIDSet), property_sourceID_already_set);
9871 m_result->setString("sourceID"_s, in_sourceID);
9872 return castState<SourceIDSet>();
9873 }
9874
9875 Builder<STATE | NameSet>& setName(const String& in_name)
9876 {
9877 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
9878 m_result->setString("name"_s, in_name);
9879 return castState<NameSet>();
9880 }
9881
9882 Builder<STATE | LineSet>& setLine(int in_line)
9883 {
9884 COMPILE_ASSERT(!(STATE & LineSet), property_line_already_set);
9885 m_result->setInteger("line"_s, in_line);
9886 return castState<LineSet>();
9887 }
9888
9889 Builder<STATE | ColumnSet>& setColumn(int in_column)
9890 {
9891 COMPILE_ASSERT(!(STATE & ColumnSet), property_column_already_set);
9892 m_result->setInteger("column"_s, in_column);
9893 return castState<ColumnSet>();
9894 }
9895
9896 Builder<STATE | UrlSet>& setUrl(const String& in_url)
9897 {
9898 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
9899 m_result->setString("url"_s, in_url);
9900 return castState<UrlSet>();
9901 }
9902
9903 Ref<StackFrame> release()
9904 {
9905 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9906 COMPILE_ASSERT(sizeof(StackFrame) == sizeof(JSON::Object), cannot_cast);
9907
9908 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9909 auto result = WTFMove(*reinterpret_cast<Ref<StackFrame>*>(&jsonResult));
9910 return result;
9911 }
9912 };
9913
9914 /*
9915 * Synthetic constructor:
9916 * Ref<StackFrame> result = StackFrame::create()
9917 * .setSourceID(...)
9918 * .setName(...)
9919 * .setLine(...)
9920 * .setColumn(...)
9921 * .setUrl(...)
9922 * .release();
9923 */
9924 static Builder<NoFieldsSet> create()
9925 {
9926 return Builder<NoFieldsSet>(JSON::Object::create());
9927 }
9928
9929 void setExpressionLocation(Ref<Protocol::ScriptProfiler::ExpressionLocation>&& in_opt_expressionLocation)
9930 {
9931 JSON::ObjectBase::setObject("expressionLocation"_s, WTFMove(in_opt_expressionLocation));
9932 }
9933};
9934
9935class StackTrace final : public JSON::ObjectBase {
9936public:
9937 enum {
9938 NoFieldsSet = 0,
9939 TimestampSet = 1 << 0,
9940 StackFramesSet = 1 << 1,
9941 AllFieldsSet = (TimestampSet | StackFramesSet)
9942 };
9943
9944 template<int STATE>
9945 class Builder {
9946 private:
9947 RefPtr<JSON::Object> m_result;
9948
9949 template<int STEP> Builder<STATE | STEP>& castState()
9950 {
9951 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9952 }
9953
9954 Builder(Ref</*StackTrace*/JSON::Object>&& object)
9955 : m_result(WTFMove(object))
9956 {
9957 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9958 }
9959 friend class StackTrace;
9960 public:
9961
9962 Builder<STATE | TimestampSet>& setTimestamp(double in_timestamp)
9963 {
9964 COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
9965 m_result->setDouble("timestamp"_s, in_timestamp);
9966 return castState<TimestampSet>();
9967 }
9968
9969 Builder<STATE | StackFramesSet>& setStackFrames(Ref<JSON::ArrayOf<Protocol::ScriptProfiler::StackFrame>>&& in_stackFrames)
9970 {
9971 COMPILE_ASSERT(!(STATE & StackFramesSet), property_stackFrames_already_set);
9972 m_result->setArray("stackFrames"_s, WTFMove(in_stackFrames));
9973 return castState<StackFramesSet>();
9974 }
9975
9976 Ref<StackTrace> release()
9977 {
9978 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9979 COMPILE_ASSERT(sizeof(StackTrace) == sizeof(JSON::Object), cannot_cast);
9980
9981 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9982 auto result = WTFMove(*reinterpret_cast<Ref<StackTrace>*>(&jsonResult));
9983 return result;
9984 }
9985 };
9986
9987 /*
9988 * Synthetic constructor:
9989 * Ref<StackTrace> result = StackTrace::create()
9990 * .setTimestamp(...)
9991 * .setStackFrames(...)
9992 * .release();
9993 */
9994 static Builder<NoFieldsSet> create()
9995 {
9996 return Builder<NoFieldsSet>(JSON::Object::create());
9997 }
9998};
9999
10000class Samples final : public JSON::ObjectBase {
10001public:
10002 enum {
10003 NoFieldsSet = 0,
10004 StackTracesSet = 1 << 0,
10005 AllFieldsSet = (StackTracesSet)
10006 };
10007
10008 template<int STATE>
10009 class Builder {
10010 private:
10011 RefPtr<JSON::Object> m_result;
10012
10013 template<int STEP> Builder<STATE | STEP>& castState()
10014 {
10015 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
10016 }
10017
10018 Builder(Ref</*Samples*/JSON::Object>&& object)
10019 : m_result(WTFMove(object))
10020 {
10021 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10022 }
10023 friend class Samples;
10024 public:
10025
10026 Builder<STATE | StackTracesSet>& setStackTraces(Ref<JSON::ArrayOf<Protocol::ScriptProfiler::StackTrace>>&& in_stackTraces)
10027 {
10028 COMPILE_ASSERT(!(STATE & StackTracesSet), property_stackTraces_already_set);
10029 m_result->setArray("stackTraces"_s, WTFMove(in_stackTraces));
10030 return castState<StackTracesSet>();
10031 }
10032
10033 Ref<Samples> release()
10034 {
10035 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10036 COMPILE_ASSERT(sizeof(Samples) == sizeof(JSON::Object), cannot_cast);
10037
10038 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10039 auto result = WTFMove(*reinterpret_cast<Ref<Samples>*>(&jsonResult));
10040 return result;
10041 }
10042 };
10043
10044 /*
10045 * Synthetic constructor:
10046 * Ref<Samples> result = Samples::create()
10047 * .setStackTraces(...)
10048 * .release();
10049 */
10050 static Builder<NoFieldsSet> create()
10051 {
10052 return Builder<NoFieldsSet>(JSON::Object::create());
10053 }
10054};
10055
10056} // ScriptProfiler
10057
10058namespace Security {
10059
10060/* Information about a SSL connection to display in the frontend. */
10061class Connection final : public JSON::ObjectBase {
10062public:
10063 enum {
10064 NoFieldsSet = 0,
10065 AllFieldsSet = 0
10066 };
10067
10068 template<int STATE>
10069 class Builder {
10070 private:
10071 RefPtr<JSON::Object> m_result;
10072
10073 template<int STEP> Builder<STATE | STEP>& castState()
10074 {
10075 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
10076 }
10077
10078 Builder(Ref</*Connection*/JSON::Object>&& object)
10079 : m_result(WTFMove(object))
10080 {
10081 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10082 }
10083 friend class Connection;
10084 public:
10085
10086 Ref<Connection> release()
10087 {
10088 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10089 COMPILE_ASSERT(sizeof(Connection) == sizeof(JSON::Object), cannot_cast);
10090
10091 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10092 auto result = WTFMove(*reinterpret_cast<Ref<Connection>*>(&jsonResult));
10093 return result;
10094 }
10095 };
10096
10097 /*
10098 * Synthetic constructor:
10099 * Ref<Connection> result = Connection::create()
10100 * .release();
10101 */
10102 static Builder<NoFieldsSet> create()
10103 {
10104 return Builder<NoFieldsSet>(JSON::Object::create());
10105 }
10106
10107 void setProtocol(const String& in_opt_protocol)
10108 {
10109 JSON::ObjectBase::setString("protocol"_s, in_opt_protocol);
10110 }
10111
10112 void setCipher(const String& in_opt_cipher)
10113 {
10114 JSON::ObjectBase::setString("cipher"_s, in_opt_cipher);
10115 }
10116};
10117
10118/* Information about a SSL certificate to display in the frontend. */
10119class Certificate final : public JSON::ObjectBase {
10120public:
10121 enum {
10122 NoFieldsSet = 0,
10123 AllFieldsSet = 0
10124 };
10125
10126 template<int STATE>
10127 class Builder {
10128 private:
10129 RefPtr<JSON::Object> m_result;
10130
10131 template<int STEP> Builder<STATE | STEP>& castState()
10132 {
10133 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
10134 }
10135
10136 Builder(Ref</*Certificate*/JSON::Object>&& object)
10137 : m_result(WTFMove(object))
10138 {
10139 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10140 }
10141 friend class Certificate;
10142 public:
10143
10144 Ref<Certificate> release()
10145 {
10146 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10147 COMPILE_ASSERT(sizeof(Certificate) == sizeof(JSON::Object), cannot_cast);
10148
10149 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10150 auto result = WTFMove(*reinterpret_cast<Ref<Certificate>*>(&jsonResult));
10151 return result;
10152 }
10153 };
10154
10155 /*
10156 * Synthetic constructor:
10157 * Ref<Certificate> result = Certificate::create()
10158 * .release();
10159 */
10160 static Builder<NoFieldsSet> create()
10161 {
10162 return Builder<NoFieldsSet>(JSON::Object::create());
10163 }
10164
10165 void setSubject(const String& in_opt_subject)
10166 {
10167 JSON::ObjectBase::setString("subject"_s, in_opt_subject);
10168 }
10169
10170 void setValidFrom(double in_opt_validFrom)
10171 {
10172 JSON::ObjectBase::setDouble("validFrom"_s, in_opt_validFrom);
10173 }
10174
10175 void setValidUntil(double in_opt_validUntil)
10176 {
10177 JSON::ObjectBase::setDouble("validUntil"_s, in_opt_validUntil);
10178 }
10179
10180 void setDnsNames(Ref<JSON::ArrayOf<String>>&& in_opt_dnsNames)
10181 {
10182 JSON::ObjectBase::setArray("dnsNames"_s, WTFMove(in_opt_dnsNames));
10183 }
10184
10185 void setIpAddresses(Ref<JSON::ArrayOf<String>>&& in_opt_ipAddresses)
10186 {
10187 JSON::ObjectBase::setArray("ipAddresses"_s, WTFMove(in_opt_ipAddresses));
10188 }
10189};
10190
10191/* Security information for a given Network.Response. */
10192class Security final : public JSON::ObjectBase {
10193public:
10194 enum {
10195 NoFieldsSet = 0,
10196 AllFieldsSet = 0
10197 };
10198
10199 template<int STATE>
10200 class Builder {
10201 private:
10202 RefPtr<JSON::Object> m_result;
10203
10204 template<int STEP> Builder<STATE | STEP>& castState()
10205 {
10206 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
10207 }
10208
10209 Builder(Ref</*Security*/JSON::Object>&& object)
10210 : m_result(WTFMove(object))
10211 {
10212 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10213 }
10214 friend class Security;
10215 public:
10216
10217 Ref<Security> release()
10218 {
10219 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10220 COMPILE_ASSERT(sizeof(Security) == sizeof(JSON::Object), cannot_cast);
10221
10222 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10223 auto result = WTFMove(*reinterpret_cast<Ref<Security>*>(&jsonResult));
10224 return result;
10225 }
10226 };
10227
10228 /*
10229 * Synthetic constructor:
10230 * Ref<Security> result = Security::create()
10231 * .release();
10232 */
10233 static Builder<NoFieldsSet> create()
10234 {
10235 return Builder<NoFieldsSet>(JSON::Object::create());
10236 }
10237
10238 void setConnection(Ref<Protocol::Security::Connection>&& in_opt_connection)
10239 {
10240 JSON::ObjectBase::setObject("connection"_s, WTFMove(in_opt_connection));
10241 }
10242
10243 void setCertificate(Ref<Protocol::Security::Certificate>&& in_opt_certificate)
10244 {
10245 JSON::ObjectBase::setObject("certificate"_s, WTFMove(in_opt_certificate));
10246 }
10247};
10248
10249} // Security
10250
10251#if defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER
10252namespace ServiceWorker {
10253
10254/* ServiceWorker metadata and initial state. */
10255class Configuration final : public JSON::ObjectBase {
10256public:
10257 enum {
10258 NoFieldsSet = 0,
10259 TargetIdSet = 1 << 0,
10260 SecurityOriginSet = 1 << 1,
10261 UrlSet = 1 << 2,
10262 ContentSet = 1 << 3,
10263 AllFieldsSet = (TargetIdSet | SecurityOriginSet | UrlSet | ContentSet)
10264 };
10265
10266 template<int STATE>
10267 class Builder {
10268 private:
10269 RefPtr<JSON::Object> m_result;
10270
10271 template<int STEP> Builder<STATE | STEP>& castState()
10272 {
10273 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
10274 }
10275
10276 Builder(Ref</*Configuration*/JSON::Object>&& object)
10277 : m_result(WTFMove(object))
10278 {
10279 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10280 }
10281 friend class Configuration;
10282 public:
10283
10284 Builder<STATE | TargetIdSet>& setTargetId(const String& in_targetId)
10285 {
10286 COMPILE_ASSERT(!(STATE & TargetIdSet), property_targetId_already_set);
10287 m_result->setString("targetId"_s, in_targetId);
10288 return castState<TargetIdSet>();
10289 }
10290
10291 Builder<STATE | SecurityOriginSet>& setSecurityOrigin(const String& in_securityOrigin)
10292 {
10293 COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
10294 m_result->setString("securityOrigin"_s, in_securityOrigin);
10295 return castState<SecurityOriginSet>();
10296 }
10297
10298 Builder<STATE | UrlSet>& setUrl(const String& in_url)
10299 {
10300 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
10301 m_result->setString("url"_s, in_url);
10302 return castState<UrlSet>();
10303 }
10304
10305 Builder<STATE | ContentSet>& setContent(const String& in_content)
10306 {
10307 COMPILE_ASSERT(!(STATE & ContentSet), property_content_already_set);
10308 m_result->setString("content"_s, in_content);
10309 return castState<ContentSet>();
10310 }
10311
10312 Ref<Configuration> release()
10313 {
10314 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10315 COMPILE_ASSERT(sizeof(Configuration) == sizeof(JSON::Object), cannot_cast);
10316
10317 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10318 auto result = WTFMove(*reinterpret_cast<Ref<Configuration>*>(&jsonResult));
10319 return result;
10320 }
10321 };
10322
10323 /*
10324 * Synthetic constructor:
10325 * Ref<Configuration> result = Configuration::create()
10326 * .setTargetId(...)
10327 * .setSecurityOrigin(...)
10328 * .setUrl(...)
10329 * .setContent(...)
10330 * .release();
10331 */
10332 static Builder<NoFieldsSet> create()
10333 {
10334 return Builder<NoFieldsSet>(JSON::Object::create());
10335 }
10336};
10337
10338} // ServiceWorker
10339#endif // defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER
10340
10341namespace Target {
10342
10343/* Description of a target. */
10344class TargetInfo final : public JSON::ObjectBase {
10345public:
10346 // Named after property name 'type' while generating TargetInfo.
10347 enum class Type {
10348 Page = 104,
10349 ServiceWorker = 142,
10350 Worker = 214,
10351 }; // enum class Type
10352
10353 enum {
10354 NoFieldsSet = 0,
10355 TargetIdSet = 1 << 0,
10356 TypeSet = 1 << 1,
10357 AllFieldsSet = (TargetIdSet | TypeSet)
10358 };
10359
10360 template<int STATE>
10361 class Builder {
10362 private:
10363 RefPtr<JSON::Object> m_result;
10364
10365 template<int STEP> Builder<STATE | STEP>& castState()
10366 {
10367 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
10368 }
10369
10370 Builder(Ref</*TargetInfo*/JSON::Object>&& object)
10371 : m_result(WTFMove(object))
10372 {
10373 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10374 }
10375 friend class TargetInfo;
10376 public:
10377
10378 Builder<STATE | TargetIdSet>& setTargetId(const String& in_targetId)
10379 {
10380 COMPILE_ASSERT(!(STATE & TargetIdSet), property_targetId_already_set);
10381 m_result->setString("targetId"_s, in_targetId);
10382 return castState<TargetIdSet>();
10383 }
10384
10385 Builder<STATE | TypeSet>& setType(Type in_type)
10386 {
10387 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
10388 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
10389 return castState<TypeSet>();
10390 }
10391
10392 Ref<TargetInfo> release()
10393 {
10394 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10395 COMPILE_ASSERT(sizeof(TargetInfo) == sizeof(JSON::Object), cannot_cast);
10396
10397 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10398 auto result = WTFMove(*reinterpret_cast<Ref<TargetInfo>*>(&jsonResult));
10399 return result;
10400 }
10401 };
10402
10403 /*
10404 * Synthetic constructor:
10405 * Ref<TargetInfo> result = TargetInfo::create()
10406 * .setTargetId(...)
10407 * .setType(...)
10408 * .release();
10409 */
10410 static Builder<NoFieldsSet> create()
10411 {
10412 return Builder<NoFieldsSet>(JSON::Object::create());
10413 }
10414
10415 void setIsProvisional(bool in_opt_isProvisional)
10416 {
10417 JSON::ObjectBase::setBoolean("isProvisional"_s, in_opt_isProvisional);
10418 }
10419
10420 void setIsPaused(bool in_opt_isPaused)
10421 {
10422 JSON::ObjectBase::setBoolean("isPaused"_s, in_opt_isPaused);
10423 }
10424};
10425
10426} // Target
10427
10428namespace Timeline {
10429
10430/* Timeline record type. */
10431enum class EventType {
10432 EventDispatch = 215,
10433 ScheduleStyleRecalculation = 216,
10434 RecalculateStyles = 217,
10435 InvalidateLayout = 218,
10436 Layout = 219,
10437 Paint = 220,
10438 Composite = 221,
10439 RenderingFrame = 222,
10440 TimerInstall = 223,
10441 TimerRemove = 224,
10442 TimerFire = 225,
10443 EvaluateScript = 226,
10444 TimeStamp = 227,
10445 Time = 228,
10446 TimeEnd = 229,
10447 FunctionCall = 230,
10448 ProbeSample = 231,
10449 ConsoleProfile = 232,
10450 RequestAnimationFrame = 233,
10451 CancelAnimationFrame = 234,
10452 FireAnimationFrame = 235,
10453 ObserverCallback = 236,
10454}; // enum class EventType
10455
10456/* Instrument types. */
10457enum class Instrument {
10458 ScriptProfiler = 237,
10459 Timeline = 238,
10460 CPU = 239,
10461 Memory = 240,
10462 Heap = 241,
10463 Animation = 242,
10464}; // enum class Instrument
10465
10466/* Timeline record contains information about the recorded activity. */
10467class TimelineEvent final : public JSON::Object {
10468public:
10469 enum {
10470 NoFieldsSet = 0,
10471 TypeSet = 1 << 0,
10472 DataSet = 1 << 1,
10473 AllFieldsSet = (TypeSet | DataSet)
10474 };
10475
10476 template<int STATE>
10477 class Builder {
10478 private:
10479 RefPtr<JSON::Object> m_result;
10480
10481 template<int STEP> Builder<STATE | STEP>& castState()
10482 {
10483 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
10484 }
10485
10486 Builder(Ref</*TimelineEvent*/JSON::Object>&& object)
10487 : m_result(WTFMove(object))
10488 {
10489 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10490 }
10491 friend class TimelineEvent;
10492 public:
10493
10494 Builder<STATE | TypeSet>& setType(Protocol::Timeline::EventType in_type)
10495 {
10496 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
10497 m_result->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
10498 return castState<TypeSet>();
10499 }
10500
10501 Builder<STATE | DataSet>& setData(Ref<JSON::Object>&& in_data)
10502 {
10503 COMPILE_ASSERT(!(STATE & DataSet), property_data_already_set);
10504 m_result->setObject("data"_s, WTFMove(in_data));
10505 return castState<DataSet>();
10506 }
10507
10508 Ref<TimelineEvent> release()
10509 {
10510 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10511 COMPILE_ASSERT(sizeof(TimelineEvent) == sizeof(JSON::Object), cannot_cast);
10512
10513 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10514 auto result = WTFMove(*reinterpret_cast<Ref<TimelineEvent>*>(&jsonResult));
10515 return result;
10516 }
10517 };
10518
10519 /*
10520 * Synthetic constructor:
10521 * Ref<TimelineEvent> result = TimelineEvent::create()
10522 * .setType(...)
10523 * .setData(...)
10524 * .release();
10525 */
10526 static Builder<NoFieldsSet> create()
10527 {
10528 return Builder<NoFieldsSet>(JSON::Object::create());
10529 }
10530
10531 void setChildren(Ref<JSON::ArrayOf<Protocol::Timeline::TimelineEvent>>&& in_opt_children)
10532 {
10533 JSON::ObjectBase::setArray("children"_s, WTFMove(in_opt_children));
10534 }
10535
10536 // Property names for type generated as open.
10537 JS_EXPORT_PRIVATE static const ASCIILiteral typeKey;
10538 JS_EXPORT_PRIVATE static const ASCIILiteral dataKey;
10539 JS_EXPORT_PRIVATE static const ASCIILiteral childrenKey;
10540};
10541
10542} // Timeline
10543
10544template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::Location> {
10545static void assertValueHasExpectedType(JSON::Value*);
10546};
10547template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::FunctionDetails> {
10548static Ref<Protocol::Debugger::FunctionDetails> runtimeCast(Ref<JSON::Value>&& value);
10549static void assertValueHasExpectedType(JSON::Value*);
10550};
10551template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::CallFrame> {
10552static Ref<Protocol::Debugger::CallFrame> runtimeCast(Ref<JSON::Value>&& value);
10553static void assertValueHasExpectedType(JSON::Value*);
10554};
10555template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::Scope> {
10556static void assertValueHasExpectedType(JSON::Value*);
10557};
10558template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::Scope::Type> {
10559static void assertValueHasExpectedType(JSON::Value*);
10560};
10561template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::RemoteObject> {
10562static Ref<Protocol::Runtime::RemoteObject> runtimeCast(Ref<JSON::Value>&& value);
10563static void assertValueHasExpectedType(JSON::Value*);
10564};
10565template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::RemoteObject::Type> {
10566static void assertValueHasExpectedType(JSON::Value*);
10567};
10568template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::RemoteObject::Subtype> {
10569static void assertValueHasExpectedType(JSON::Value*);
10570};
10571template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::ObjectPreview> {
10572static Ref<Protocol::Runtime::ObjectPreview> runtimeCast(Ref<JSON::Value>&& value);
10573static void assertValueHasExpectedType(JSON::Value*);
10574};
10575template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::ObjectPreview::Type> {
10576static void assertValueHasExpectedType(JSON::Value*);
10577};
10578template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::ObjectPreview::Subtype> {
10579static void assertValueHasExpectedType(JSON::Value*);
10580};
10581template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyPreview> {
10582static void assertValueHasExpectedType(JSON::Value*);
10583};
10584template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyPreview::Type> {
10585static void assertValueHasExpectedType(JSON::Value*);
10586};
10587template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyPreview::Subtype> {
10588static void assertValueHasExpectedType(JSON::Value*);
10589};
10590template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::EntryPreview> {
10591static void assertValueHasExpectedType(JSON::Value*);
10592};
10593template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::CollectionEntry> {
10594static Ref<Protocol::Runtime::CollectionEntry> runtimeCast(Ref<JSON::Value>&& value);
10595static void assertValueHasExpectedType(JSON::Value*);
10596};
10597template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyDescriptor> {
10598static Ref<Protocol::Runtime::PropertyDescriptor> runtimeCast(Ref<JSON::Value>&& value);
10599static void assertValueHasExpectedType(JSON::Value*);
10600};
10601template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::InternalPropertyDescriptor> {
10602static Ref<Protocol::Runtime::InternalPropertyDescriptor> runtimeCast(Ref<JSON::Value>&& value);
10603static void assertValueHasExpectedType(JSON::Value*);
10604};
10605template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Timeline::TimelineEvent> {
10606static Ref<Protocol::Timeline::TimelineEvent> runtimeCast(Ref<JSON::Value>&& value);
10607static void assertValueHasExpectedType(JSON::Value*);
10608};
10609template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Timeline::EventType> {
10610static void assertValueHasExpectedType(JSON::Value*);
10611};
10612
10613namespace Helpers {
10614
10615template<typename ProtocolEnumType>
10616std::optional<ProtocolEnumType> parseEnumValueFromString(const String&);
10617
10618// Enums in the 'Animation' Domain
10619template<>
10620JS_EXPORT_PRIVATE std::optional<Protocol::Animation::AnimationState> parseEnumValueFromString<Protocol::Animation::AnimationState>(const String&);
10621template<>
10622JS_EXPORT_PRIVATE std::optional<Protocol::Animation::PlaybackDirection> parseEnumValueFromString<Protocol::Animation::PlaybackDirection>(const String&);
10623template<>
10624JS_EXPORT_PRIVATE std::optional<Protocol::Animation::FillMode> parseEnumValueFromString<Protocol::Animation::FillMode>(const String&);
10625
10626#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
10627// Enums in the 'CPUProfiler' Domain
10628template<>
10629JS_EXPORT_PRIVATE std::optional<Protocol::CPUProfiler::ThreadInfo::Type> parseEnumValueFromString<Protocol::CPUProfiler::ThreadInfo::Type>(const String&);
10630#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
10631
10632// Enums in the 'CSS' Domain
10633template<>
10634JS_EXPORT_PRIVATE std::optional<Protocol::CSS::StyleSheetOrigin> parseEnumValueFromString<Protocol::CSS::StyleSheetOrigin>(const String&);
10635template<>
10636JS_EXPORT_PRIVATE std::optional<Protocol::CSS::PseudoId> parseEnumValueFromString<Protocol::CSS::PseudoId>(const String&);
10637template<>
10638JS_EXPORT_PRIVATE std::optional<Protocol::CSS::CSSPropertyStatus> parseEnumValueFromString<Protocol::CSS::CSSPropertyStatus>(const String&);
10639template<>
10640JS_EXPORT_PRIVATE std::optional<Protocol::CSS::LayoutContextType> parseEnumValueFromString<Protocol::CSS::LayoutContextType>(const String&);
10641template<>
10642JS_EXPORT_PRIVATE std::optional<Protocol::CSS::LayoutContextTypeChangedMode> parseEnumValueFromString<Protocol::CSS::LayoutContextTypeChangedMode>(const String&);
10643template<>
10644JS_EXPORT_PRIVATE std::optional<Protocol::CSS::Grouping::Type> parseEnumValueFromString<Protocol::CSS::Grouping::Type>(const String&);
10645
10646// Enums in the 'Canvas' Domain
10647template<>
10648JS_EXPORT_PRIVATE std::optional<Protocol::Canvas::ContextType> parseEnumValueFromString<Protocol::Canvas::ContextType>(const String&);
10649#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10650template<>
10651JS_EXPORT_PRIVATE std::optional<Protocol::Canvas::ProgramType> parseEnumValueFromString<Protocol::Canvas::ProgramType>(const String&);
10652#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10653#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10654template<>
10655JS_EXPORT_PRIVATE std::optional<Protocol::Canvas::ShaderType> parseEnumValueFromString<Protocol::Canvas::ShaderType>(const String&);
10656#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10657
10658// Enums in the 'Console' Domain
10659template<>
10660JS_EXPORT_PRIVATE std::optional<Protocol::Console::ChannelSource> parseEnumValueFromString<Protocol::Console::ChannelSource>(const String&);
10661template<>
10662JS_EXPORT_PRIVATE std::optional<Protocol::Console::ChannelLevel> parseEnumValueFromString<Protocol::Console::ChannelLevel>(const String&);
10663template<>
10664JS_EXPORT_PRIVATE std::optional<Protocol::Console::ConsoleMessage::Level> parseEnumValueFromString<Protocol::Console::ConsoleMessage::Level>(const String&);
10665template<>
10666JS_EXPORT_PRIVATE std::optional<Protocol::Console::ConsoleMessage::Type> parseEnumValueFromString<Protocol::Console::ConsoleMessage::Type>(const String&);
10667
10668// Enums in the 'DOM' Domain
10669template<>
10670JS_EXPORT_PRIVATE std::optional<Protocol::DOM::PseudoType> parseEnumValueFromString<Protocol::DOM::PseudoType>(const String&);
10671template<>
10672JS_EXPORT_PRIVATE std::optional<Protocol::DOM::ShadowRootType> parseEnumValueFromString<Protocol::DOM::ShadowRootType>(const String&);
10673template<>
10674JS_EXPORT_PRIVATE std::optional<Protocol::DOM::CustomElementState> parseEnumValueFromString<Protocol::DOM::CustomElementState>(const String&);
10675template<>
10676JS_EXPORT_PRIVATE std::optional<Protocol::DOM::LiveRegionRelevant> parseEnumValueFromString<Protocol::DOM::LiveRegionRelevant>(const String&);
10677template<>
10678JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::Checked> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::Checked>(const String&);
10679template<>
10680JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::Current> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::Current>(const String&);
10681template<>
10682JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::Invalid> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::Invalid>(const String&);
10683template<>
10684JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::LiveRegionStatus> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::LiveRegionStatus>(const String&);
10685
10686// Enums in the 'DOMDebugger' Domain
10687template<>
10688JS_EXPORT_PRIVATE std::optional<Protocol::DOMDebugger::DOMBreakpointType> parseEnumValueFromString<Protocol::DOMDebugger::DOMBreakpointType>(const String&);
10689template<>
10690JS_EXPORT_PRIVATE std::optional<Protocol::DOMDebugger::EventBreakpointType> parseEnumValueFromString<Protocol::DOMDebugger::EventBreakpointType>(const String&);
10691
10692// Enums in the 'Debugger' Domain
10693template<>
10694JS_EXPORT_PRIVATE std::optional<Protocol::Debugger::BreakpointAction::Type> parseEnumValueFromString<Protocol::Debugger::BreakpointAction::Type>(const String&);
10695template<>
10696JS_EXPORT_PRIVATE std::optional<Protocol::Debugger::Scope::Type> parseEnumValueFromString<Protocol::Debugger::Scope::Type>(const String&);
10697
10698// Enums in the 'Heap' Domain
10699template<>
10700JS_EXPORT_PRIVATE std::optional<Protocol::Heap::GarbageCollection::Type> parseEnumValueFromString<Protocol::Heap::GarbageCollection::Type>(const String&);
10701
10702// Enums in the 'IndexedDB' Domain
10703template<>
10704JS_EXPORT_PRIVATE std::optional<Protocol::IndexedDB::Key::Type> parseEnumValueFromString<Protocol::IndexedDB::Key::Type>(const String&);
10705template<>
10706JS_EXPORT_PRIVATE std::optional<Protocol::IndexedDB::KeyPath::Type> parseEnumValueFromString<Protocol::IndexedDB::KeyPath::Type>(const String&);
10707
10708#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
10709// Enums in the 'Memory' Domain
10710template<>
10711JS_EXPORT_PRIVATE std::optional<Protocol::Memory::CategoryData::Type> parseEnumValueFromString<Protocol::Memory::CategoryData::Type>(const String&);
10712#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
10713
10714// Enums in the 'Network' Domain
10715template<>
10716JS_EXPORT_PRIVATE std::optional<Protocol::Network::NetworkStage> parseEnumValueFromString<Protocol::Network::NetworkStage>(const String&);
10717template<>
10718JS_EXPORT_PRIVATE std::optional<Protocol::Network::ResourceErrorType> parseEnumValueFromString<Protocol::Network::ResourceErrorType>(const String&);
10719template<>
10720JS_EXPORT_PRIVATE std::optional<Protocol::Network::Response::Source> parseEnumValueFromString<Protocol::Network::Response::Source>(const String&);
10721template<>
10722JS_EXPORT_PRIVATE std::optional<Protocol::Network::Metrics::Priority> parseEnumValueFromString<Protocol::Network::Metrics::Priority>(const String&);
10723template<>
10724JS_EXPORT_PRIVATE std::optional<Protocol::Network::Initiator::Type> parseEnumValueFromString<Protocol::Network::Initiator::Type>(const String&);
10725
10726// Enums in the 'Page' Domain
10727template<>
10728JS_EXPORT_PRIVATE std::optional<Protocol::Page::Setting> parseEnumValueFromString<Protocol::Page::Setting>(const String&);
10729template<>
10730JS_EXPORT_PRIVATE std::optional<Protocol::Page::ResourceType> parseEnumValueFromString<Protocol::Page::ResourceType>(const String&);
10731template<>
10732JS_EXPORT_PRIVATE std::optional<Protocol::Page::CoordinateSystem> parseEnumValueFromString<Protocol::Page::CoordinateSystem>(const String&);
10733template<>
10734JS_EXPORT_PRIVATE std::optional<Protocol::Page::CookieSameSitePolicy> parseEnumValueFromString<Protocol::Page::CookieSameSitePolicy>(const String&);
10735#if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
10736template<>
10737JS_EXPORT_PRIVATE std::optional<Protocol::Page::Appearance> parseEnumValueFromString<Protocol::Page::Appearance>(const String&);
10738#endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
10739
10740// Enums in the 'Recording' Domain
10741template<>
10742JS_EXPORT_PRIVATE std::optional<Protocol::Recording::Type> parseEnumValueFromString<Protocol::Recording::Type>(const String&);
10743template<>
10744JS_EXPORT_PRIVATE std::optional<Protocol::Recording::Initiator> parseEnumValueFromString<Protocol::Recording::Initiator>(const String&);
10745
10746// Enums in the 'Runtime' Domain
10747template<>
10748JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::ExecutionContextType> parseEnumValueFromString<Protocol::Runtime::ExecutionContextType>(const String&);
10749template<>
10750JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::SyntaxErrorType> parseEnumValueFromString<Protocol::Runtime::SyntaxErrorType>(const String&);
10751template<>
10752JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::RemoteObject::Type> parseEnumValueFromString<Protocol::Runtime::RemoteObject::Type>(const String&);
10753template<>
10754JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::RemoteObject::Subtype> parseEnumValueFromString<Protocol::Runtime::RemoteObject::Subtype>(const String&);
10755template<>
10756JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::ObjectPreview::Type> parseEnumValueFromString<Protocol::Runtime::ObjectPreview::Type>(const String&);
10757template<>
10758JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::ObjectPreview::Subtype> parseEnumValueFromString<Protocol::Runtime::ObjectPreview::Subtype>(const String&);
10759template<>
10760JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::PropertyPreview::Type> parseEnumValueFromString<Protocol::Runtime::PropertyPreview::Type>(const String&);
10761template<>
10762JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::PropertyPreview::Subtype> parseEnumValueFromString<Protocol::Runtime::PropertyPreview::Subtype>(const String&);
10763
10764// Enums in the 'ScriptProfiler' Domain
10765template<>
10766JS_EXPORT_PRIVATE std::optional<Protocol::ScriptProfiler::EventType> parseEnumValueFromString<Protocol::ScriptProfiler::EventType>(const String&);
10767
10768// Enums in the 'Target' Domain
10769template<>
10770JS_EXPORT_PRIVATE std::optional<Protocol::Target::TargetInfo::Type> parseEnumValueFromString<Protocol::Target::TargetInfo::Type>(const String&);
10771
10772// Enums in the 'Timeline' Domain
10773template<>
10774JS_EXPORT_PRIVATE std::optional<Protocol::Timeline::EventType> parseEnumValueFromString<Protocol::Timeline::EventType>(const String&);
10775template<>
10776JS_EXPORT_PRIVATE std::optional<Protocol::Timeline::Instrument> parseEnumValueFromString<Protocol::Timeline::Instrument>(const String&);
10777
10778} // namespace Helpers
10779
10780} // namespace Protocol
10781
10782} // namespace Inspector
10783
10784namespace WTF {
10785
10786template<typename T> struct DefaultHash;
10787
10788// Hash declarations in the 'Animation' Domain
10789template<>
10790struct DefaultHash<Inspector::Protocol::Animation::AnimationState> : IntHash<Inspector::Protocol::Animation::AnimationState> { };
10791template<>
10792struct DefaultHash<Inspector::Protocol::Animation::PlaybackDirection> : IntHash<Inspector::Protocol::Animation::PlaybackDirection> { };
10793template<>
10794struct DefaultHash<Inspector::Protocol::Animation::FillMode> : IntHash<Inspector::Protocol::Animation::FillMode> { };
10795
10796// Hash declarations in the 'CSS' Domain
10797template<>
10798struct DefaultHash<Inspector::Protocol::CSS::StyleSheetOrigin> : IntHash<Inspector::Protocol::CSS::StyleSheetOrigin> { };
10799template<>
10800struct DefaultHash<Inspector::Protocol::CSS::PseudoId> : IntHash<Inspector::Protocol::CSS::PseudoId> { };
10801template<>
10802struct DefaultHash<Inspector::Protocol::CSS::CSSPropertyStatus> : IntHash<Inspector::Protocol::CSS::CSSPropertyStatus> { };
10803template<>
10804struct DefaultHash<Inspector::Protocol::CSS::LayoutContextType> : IntHash<Inspector::Protocol::CSS::LayoutContextType> { };
10805template<>
10806struct DefaultHash<Inspector::Protocol::CSS::LayoutContextTypeChangedMode> : IntHash<Inspector::Protocol::CSS::LayoutContextTypeChangedMode> { };
10807
10808// Hash declarations in the 'Canvas' Domain
10809template<>
10810struct DefaultHash<Inspector::Protocol::Canvas::ContextType> : IntHash<Inspector::Protocol::Canvas::ContextType> { };
10811#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10812template<>
10813struct DefaultHash<Inspector::Protocol::Canvas::ProgramType> : IntHash<Inspector::Protocol::Canvas::ProgramType> { };
10814#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10815#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10816template<>
10817struct DefaultHash<Inspector::Protocol::Canvas::ShaderType> : IntHash<Inspector::Protocol::Canvas::ShaderType> { };
10818#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10819
10820// Hash declarations in the 'Console' Domain
10821template<>
10822struct DefaultHash<Inspector::Protocol::Console::ChannelSource> : IntHash<Inspector::Protocol::Console::ChannelSource> { };
10823template<>
10824struct DefaultHash<Inspector::Protocol::Console::ChannelLevel> : IntHash<Inspector::Protocol::Console::ChannelLevel> { };
10825
10826// Hash declarations in the 'DOM' Domain
10827template<>
10828struct DefaultHash<Inspector::Protocol::DOM::PseudoType> : IntHash<Inspector::Protocol::DOM::PseudoType> { };
10829template<>
10830struct DefaultHash<Inspector::Protocol::DOM::ShadowRootType> : IntHash<Inspector::Protocol::DOM::ShadowRootType> { };
10831template<>
10832struct DefaultHash<Inspector::Protocol::DOM::CustomElementState> : IntHash<Inspector::Protocol::DOM::CustomElementState> { };
10833template<>
10834struct DefaultHash<Inspector::Protocol::DOM::LiveRegionRelevant> : IntHash<Inspector::Protocol::DOM::LiveRegionRelevant> { };
10835
10836// Hash declarations in the 'DOMDebugger' Domain
10837template<>
10838struct DefaultHash<Inspector::Protocol::DOMDebugger::DOMBreakpointType> : IntHash<Inspector::Protocol::DOMDebugger::DOMBreakpointType> { };
10839template<>
10840struct DefaultHash<Inspector::Protocol::DOMDebugger::EventBreakpointType> : IntHash<Inspector::Protocol::DOMDebugger::EventBreakpointType> { };
10841
10842// Hash declarations in the 'Network' Domain
10843template<>
10844struct DefaultHash<Inspector::Protocol::Network::NetworkStage> : IntHash<Inspector::Protocol::Network::NetworkStage> { };
10845template<>
10846struct DefaultHash<Inspector::Protocol::Network::ResourceErrorType> : IntHash<Inspector::Protocol::Network::ResourceErrorType> { };
10847
10848// Hash declarations in the 'Page' Domain
10849template<>
10850struct DefaultHash<Inspector::Protocol::Page::Setting> : IntHash<Inspector::Protocol::Page::Setting> { };
10851template<>
10852struct DefaultHash<Inspector::Protocol::Page::ResourceType> : IntHash<Inspector::Protocol::Page::ResourceType> { };
10853template<>
10854struct DefaultHash<Inspector::Protocol::Page::CoordinateSystem> : IntHash<Inspector::Protocol::Page::CoordinateSystem> { };
10855template<>
10856struct DefaultHash<Inspector::Protocol::Page::CookieSameSitePolicy> : IntHash<Inspector::Protocol::Page::CookieSameSitePolicy> { };
10857#if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
10858template<>
10859struct DefaultHash<Inspector::Protocol::Page::Appearance> : IntHash<Inspector::Protocol::Page::Appearance> { };
10860#endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
10861
10862// Hash declarations in the 'Recording' Domain
10863template<>
10864struct DefaultHash<Inspector::Protocol::Recording::Type> : IntHash<Inspector::Protocol::Recording::Type> { };
10865template<>
10866struct DefaultHash<Inspector::Protocol::Recording::Initiator> : IntHash<Inspector::Protocol::Recording::Initiator> { };
10867
10868// Hash declarations in the 'Runtime' Domain
10869template<>
10870struct DefaultHash<Inspector::Protocol::Runtime::ExecutionContextType> : IntHash<Inspector::Protocol::Runtime::ExecutionContextType> { };
10871template<>
10872struct DefaultHash<Inspector::Protocol::Runtime::SyntaxErrorType> : IntHash<Inspector::Protocol::Runtime::SyntaxErrorType> { };
10873
10874// Hash declarations in the 'ScriptProfiler' Domain
10875template<>
10876struct DefaultHash<Inspector::Protocol::ScriptProfiler::EventType> : IntHash<Inspector::Protocol::ScriptProfiler::EventType> { };
10877
10878// Hash declarations in the 'Timeline' Domain
10879template<>
10880struct DefaultHash<Inspector::Protocol::Timeline::EventType> : IntHash<Inspector::Protocol::Timeline::EventType> { };
10881template<>
10882struct DefaultHash<Inspector::Protocol::Timeline::Instrument> : IntHash<Inspector::Protocol::Timeline::Instrument> { };
10883
10884} // namespace WTF
10885